src/api2/types/mod.rs

   1 use anyhow::bail;
   2 use serde::{Deserialize, Serialize};
   3
   4 use proxmox::api::{api, schema::*};
   5 use proxmox::const_regex;
   6 use proxmox::{IPRE, IPRE_BRACKET, IPV4RE, IPV6RE, IPV4OCTET, IPV6H16, IPV6LS32};
   7
   8 use crate::backup::CryptMode;
   9 use crate::server::UPID;
  10
  11 #[macro_use]
  12 mod macros;
  13
  14 #[macro_use]
  15 mod userid;
  16 pub use userid::{Realm, RealmRef};
  17 pub use userid::{Username, UsernameRef};
  18 pub use userid::Userid;
  19 pub use userid::PROXMOX_GROUP_ID_SCHEMA;
  20
  21 // File names: may not contain slashes, may not start with "."
  22 pub const FILENAME_FORMAT: ApiStringFormat = ApiStringFormat::VerifyFn(|name| {
  23     if name.starts_with('.') {
  24         bail!("file names may not start with '.'");
  25     }
  26     if name.contains('/') {
  27         bail!("file names may not contain slashes");
  28     }
  29     Ok(())
  30 });
  31
  32 macro_rules! DNS_LABEL { () => (r"(?:[a-zA-Z0-9](?:[a-zA-Z0-9\-]*[a-zA-Z0-9])?)") }
  33 macro_rules! DNS_NAME { () => (concat!(r"(?:(?:", DNS_LABEL!() , r"\.)*", DNS_LABEL!(), ")")) }
  34
  35 macro_rules! CIDR_V4_REGEX_STR { () => (concat!(r"(?:", IPV4RE!(), r"/\d{1,2})$")) }
  36 macro_rules! CIDR_V6_REGEX_STR { () => (concat!(r"(?:", IPV6RE!(), r"/\d{1,3})$")) }
  37
  38 const_regex!{
  39     pub IP_V4_REGEX = concat!(r"^", IPV4RE!(), r"$");
  40     pub IP_V6_REGEX = concat!(r"^", IPV6RE!(), r"$");
  41     pub IP_REGEX = concat!(r"^", IPRE!(), r"$");
  42     pub CIDR_V4_REGEX =  concat!(r"^", CIDR_V4_REGEX_STR!(), r"$");
  43     pub CIDR_V6_REGEX =  concat!(r"^", CIDR_V6_REGEX_STR!(), r"$");
  44     pub CIDR_REGEX =  concat!(r"^(?:", CIDR_V4_REGEX_STR!(), "|",  CIDR_V6_REGEX_STR!(), r")$");
  45
  46     pub SHA256_HEX_REGEX = r"^[a-f0-9]{64}$"; // fixme: define in common_regex ?
  47     pub SYSTEMD_DATETIME_REGEX = r"^\d{4}-\d{2}-\d{2}( \d{2}:\d{2}(:\d{2})?)?$"; //  fixme: define in common_regex ?
  48
  49     pub PASSWORD_REGEX = r"^[[:^cntrl:]]*$"; // everything but control characters
  50
  51     /// Regex for safe identifiers.
  52     ///
  53     /// This
  54     /// [article](https://dwheeler.com/essays/fixing-unix-linux-filenames.html)
  55     /// contains further information why it is reasonable to restict
  56     /// names this way. This is not only useful for filenames, but for
  57     /// any identifier command line tools work with.
  58     pub PROXMOX_SAFE_ID_REGEX = concat!(r"^", PROXMOX_SAFE_ID_REGEX_STR!(), r"$");
  59
  60     pub SINGLE_LINE_COMMENT_REGEX = r"^[[:^cntrl:]]*$";
  61
  62     pub HOSTNAME_REGEX = r"^(?:[a-zA-Z0-9](?:[a-zA-Z0-9\-]*[a-zA-Z0-9])?)$";
  63
  64     pub DNS_NAME_REGEX =  concat!(r"^", DNS_NAME!(), r"$");
  65
  66     pub DNS_NAME_OR_IP_REGEX = concat!(r"^(?:", DNS_NAME!(), "|",  IPRE!(), r")$");
  67
  68     pub BACKUP_REPO_URL_REGEX = concat!(r"^^(?:(?:(", USER_ID_REGEX_STR!(), ")@)?(", DNS_NAME!(), "|",  IPRE_BRACKET!() ,"):)?(?:([0-9]{1,5}):)?(", PROXMOX_SAFE_ID_REGEX_STR!(), r")$");
  69
  70     pub CERT_FINGERPRINT_SHA256_REGEX = r"^(?:[0-9a-fA-F][0-9a-fA-F])(?::[0-9a-fA-F][0-9a-fA-F]){31}$";
  71
  72     pub ACL_PATH_REGEX = concat!(r"^(?:/|", r"(?:/", PROXMOX_SAFE_ID_REGEX_STR!(), ")+", r")$");
  73
  74     pub BLOCKDEVICE_NAME_REGEX = r"^(:?(:?h|s|x?v)d[a-z]+)|(:?nvme\d+n\d+)$";
  75
  76     pub ZPOOL_NAME_REGEX = r"^[a-zA-Z][a-z0-9A-Z\-_.:]+$";
  77 }
  78
  79 pub const SYSTEMD_DATETIME_FORMAT: ApiStringFormat =
  80     ApiStringFormat::Pattern(&SYSTEMD_DATETIME_REGEX);
  81
  82 pub const IP_V4_FORMAT: ApiStringFormat =
  83     ApiStringFormat::Pattern(&IP_V4_REGEX);
  84
  85 pub const IP_V6_FORMAT: ApiStringFormat =
  86     ApiStringFormat::Pattern(&IP_V6_REGEX);
  87
  88 pub const IP_FORMAT: ApiStringFormat =
  89     ApiStringFormat::Pattern(&IP_REGEX);
  90
  91 pub const PVE_CONFIG_DIGEST_FORMAT: ApiStringFormat =
  92     ApiStringFormat::Pattern(&SHA256_HEX_REGEX);
  93
  94 pub const CERT_FINGERPRINT_SHA256_FORMAT: ApiStringFormat =
  95     ApiStringFormat::Pattern(&CERT_FINGERPRINT_SHA256_REGEX);
  96
  97 pub const PROXMOX_SAFE_ID_FORMAT: ApiStringFormat =
  98     ApiStringFormat::Pattern(&PROXMOX_SAFE_ID_REGEX);
  99
 100 pub const SINGLE_LINE_COMMENT_FORMAT: ApiStringFormat =
 101     ApiStringFormat::Pattern(&SINGLE_LINE_COMMENT_REGEX);
 102
 103 pub const HOSTNAME_FORMAT: ApiStringFormat =
 104     ApiStringFormat::Pattern(&HOSTNAME_REGEX);
 105
 106 pub const DNS_NAME_FORMAT: ApiStringFormat =
 107     ApiStringFormat::Pattern(&DNS_NAME_REGEX);
 108
 109 pub const DNS_NAME_OR_IP_FORMAT: ApiStringFormat =
 110     ApiStringFormat::Pattern(&DNS_NAME_OR_IP_REGEX);
 111
 112 pub const PASSWORD_FORMAT: ApiStringFormat =
 113     ApiStringFormat::Pattern(&PASSWORD_REGEX);
 114
 115 pub const ACL_PATH_FORMAT: ApiStringFormat =
 116     ApiStringFormat::Pattern(&ACL_PATH_REGEX);
 117
 118 pub const NETWORK_INTERFACE_FORMAT: ApiStringFormat =
 119     ApiStringFormat::Pattern(&PROXMOX_SAFE_ID_REGEX);
 120
 121 pub const CIDR_V4_FORMAT: ApiStringFormat =
 122     ApiStringFormat::Pattern(&CIDR_V4_REGEX);
 123
 124 pub const CIDR_V6_FORMAT: ApiStringFormat =
 125     ApiStringFormat::Pattern(&CIDR_V6_REGEX);
 126
 127 pub const CIDR_FORMAT: ApiStringFormat =
 128     ApiStringFormat::Pattern(&CIDR_REGEX);
 129
 130 pub const BLOCKDEVICE_NAME_FORMAT: ApiStringFormat =
 131     ApiStringFormat::Pattern(&BLOCKDEVICE_NAME_REGEX);
 132
 133 pub const PASSWORD_SCHEMA: Schema = StringSchema::new("Password.")
 134     .format(&PASSWORD_FORMAT)
 135     .min_length(1)
 136     .max_length(1024)
 137     .schema();
 138
 139 pub const PBS_PASSWORD_SCHEMA: Schema = StringSchema::new("User Password.")
 140     .format(&PASSWORD_FORMAT)
 141     .min_length(5)
 142     .max_length(64)
 143     .schema();
 144
 145 pub const CERT_FINGERPRINT_SHA256_SCHEMA: Schema = StringSchema::new(
 146     "X509 certificate fingerprint (sha256)."
 147 )
 148     .format(&CERT_FINGERPRINT_SHA256_FORMAT)
 149     .schema();
 150
 151 pub const PROXMOX_CONFIG_DIGEST_SCHEMA: Schema = StringSchema::new(r#"\
 152 Prevent changes if current configuration file has different SHA256 digest.
 153 This can be used to prevent concurrent modifications.
 154 "#
 155 )
 156     .format(&PVE_CONFIG_DIGEST_FORMAT)
 157     .schema();
 158
 159
 160 pub const CHUNK_DIGEST_FORMAT: ApiStringFormat =
 161     ApiStringFormat::Pattern(&SHA256_HEX_REGEX);
 162
 163 pub const CHUNK_DIGEST_SCHEMA: Schema = StringSchema::new("Chunk digest (SHA256).")
 164     .format(&CHUNK_DIGEST_FORMAT)
 165     .schema();
 166
 167 pub const NODE_SCHEMA: Schema = StringSchema::new("Node name (or 'localhost')")
 168     .format(&ApiStringFormat::VerifyFn(|node| {
 169         if node == "localhost" || node == proxmox::tools::nodename() {
 170             Ok(())
 171         } else {
 172             bail!("no such node '{}'", node);
 173         }
 174     }))
 175     .schema();
 176
 177 pub const SEARCH_DOMAIN_SCHEMA: Schema =
 178     StringSchema::new("Search domain for host-name lookup.").schema();
 179
 180 pub const FIRST_DNS_SERVER_SCHEMA: Schema =
 181     StringSchema::new("First name server IP address.")
 182     .format(&IP_FORMAT)
 183     .schema();
 184
 185 pub const SECOND_DNS_SERVER_SCHEMA: Schema =
 186     StringSchema::new("Second name server IP address.")
 187     .format(&IP_FORMAT)
 188     .schema();
 189
 190 pub const THIRD_DNS_SERVER_SCHEMA: Schema =
 191     StringSchema::new("Third name server IP address.")
 192     .format(&IP_FORMAT)
 193     .schema();
 194
 195 pub const IP_V4_SCHEMA: Schema =
 196     StringSchema::new("IPv4 address.")
 197     .format(&IP_V4_FORMAT)
 198     .max_length(15)
 199     .schema();
 200
 201 pub const IP_V6_SCHEMA: Schema =
 202     StringSchema::new("IPv6 address.")
 203     .format(&IP_V6_FORMAT)
 204     .max_length(39)
 205     .schema();
 206
 207 pub const IP_SCHEMA: Schema =
 208     StringSchema::new("IP (IPv4 or IPv6) address.")
 209     .format(&IP_FORMAT)
 210     .max_length(39)
 211     .schema();
 212
 213 pub const CIDR_V4_SCHEMA: Schema =
 214     StringSchema::new("IPv4 address with netmask (CIDR notation).")
 215     .format(&CIDR_V4_FORMAT)
 216     .max_length(18)
 217     .schema();
 218
 219 pub const CIDR_V6_SCHEMA: Schema =
 220     StringSchema::new("IPv6 address with netmask (CIDR notation).")
 221     .format(&CIDR_V6_FORMAT)
 222     .max_length(43)
 223     .schema();
 224
 225 pub const CIDR_SCHEMA: Schema =
 226     StringSchema::new("IP address (IPv4 or IPv6) with netmask (CIDR notation).")
 227     .format(&CIDR_FORMAT)
 228     .max_length(43)
 229     .schema();
 230
 231 pub const TIME_ZONE_SCHEMA: Schema = StringSchema::new(
 232     "Time zone. The file '/usr/share/zoneinfo/zone.tab' contains the list of valid names.")
 233     .format(&SINGLE_LINE_COMMENT_FORMAT)
 234     .min_length(2)
 235     .max_length(64)
 236     .schema();
 237
 238 pub const ACL_PATH_SCHEMA: Schema = StringSchema::new(
 239     "Access control path.")
 240     .format(&ACL_PATH_FORMAT)
 241     .min_length(1)
 242     .max_length(128)
 243     .schema();
 244
 245 pub const ACL_PROPAGATE_SCHEMA: Schema = BooleanSchema::new(
 246     "Allow to propagate (inherit) permissions.")
 247     .default(true)
 248     .schema();
 249
 250 pub const ACL_UGID_TYPE_SCHEMA: Schema = StringSchema::new(
 251     "Type of 'ugid' property.")
 252     .format(&ApiStringFormat::Enum(&[
 253         EnumEntry::new("user", "User"),
 254         EnumEntry::new("group", "Group")]))
 255     .schema();
 256
 257 pub const BACKUP_ARCHIVE_NAME_SCHEMA: Schema =
 258     StringSchema::new("Backup archive name.")
 259     .format(&PROXMOX_SAFE_ID_FORMAT)
 260     .schema();
 261
 262 pub const BACKUP_TYPE_SCHEMA: Schema =
 263     StringSchema::new("Backup type.")
 264     .format(&ApiStringFormat::Enum(&[
 265         EnumEntry::new("vm", "Virtual Machine Backup"),
 266         EnumEntry::new("ct", "Container Backup"),
 267         EnumEntry::new("host", "Host Backup")]))
 268     .schema();
 269
 270 pub const BACKUP_ID_SCHEMA: Schema =
 271     StringSchema::new("Backup ID.")
 272     .format(&PROXMOX_SAFE_ID_FORMAT)
 273     .schema();
 274
 275 pub const BACKUP_TIME_SCHEMA: Schema =
 276     IntegerSchema::new("Backup time (Unix epoch.)")
 277     .minimum(1_547_797_308)
 278     .schema();
 279
 280 pub const UPID_SCHEMA: Schema = StringSchema::new("Unique Process/Task ID.")
 281     .max_length(256)
 282     .schema();
 283
 284 pub const DATASTORE_SCHEMA: Schema = StringSchema::new("Datastore name.")
 285     .format(&PROXMOX_SAFE_ID_FORMAT)
 286     .min_length(3)
 287     .max_length(32)
 288     .schema();
 289
 290 pub const SYNC_SCHEDULE_SCHEMA: Schema = StringSchema::new(
 291     "Run sync job at specified schedule.")
 292     .format(&ApiStringFormat::VerifyFn(crate::tools::systemd::time::verify_calendar_event))
 293     .schema();
 294
 295 pub const GC_SCHEDULE_SCHEMA: Schema = StringSchema::new(
 296     "Run garbage collection job at specified schedule.")
 297     .format(&ApiStringFormat::VerifyFn(crate::tools::systemd::time::verify_calendar_event))
 298     .schema();
 299
 300 pub const PRUNE_SCHEDULE_SCHEMA: Schema = StringSchema::new(
 301     "Run prune job at specified schedule.")
 302     .format(&ApiStringFormat::VerifyFn(crate::tools::systemd::time::verify_calendar_event))
 303     .schema();
 304
 305 pub const VERIFICATION_SCHEDULE_SCHEMA: Schema = StringSchema::new(
 306     "Run verify job at specified schedule.")
 307     .format(&ApiStringFormat::VerifyFn(crate::tools::systemd::time::verify_calendar_event))
 308     .schema();
 309
 310 pub const REMOTE_ID_SCHEMA: Schema = StringSchema::new("Remote ID.")
 311     .format(&PROXMOX_SAFE_ID_FORMAT)
 312     .min_length(3)
 313     .max_length(32)
 314     .schema();
 315
 316 pub const JOB_ID_SCHEMA: Schema = StringSchema::new("Job ID.")
 317     .format(&PROXMOX_SAFE_ID_FORMAT)
 318     .min_length(3)
 319     .max_length(32)
 320     .schema();
 321
 322 pub const REMOVE_VANISHED_BACKUPS_SCHEMA: Schema = BooleanSchema::new(
 323     "Delete vanished backups. This remove the local copy if the remote backup was deleted.")
 324     .default(true)
 325     .schema();
 326
 327 pub const IGNORE_VERIFIED_BACKUPS_SCHEMA: Schema = BooleanSchema::new(
 328     "Do not verify backups that are already verified if their verification is not outdated.")
 329     .default(true)
 330     .schema();
 331
 332 pub const VERIFICATION_OUTDATED_AFTER_SCHEMA: Schema = IntegerSchema::new(
 333     "Days after that a verification becomes outdated")
 334     .minimum(1)
 335     .schema();
 336
 337 pub const SINGLE_LINE_COMMENT_SCHEMA: Schema = StringSchema::new("Comment (single line).")
 338     .format(&SINGLE_LINE_COMMENT_FORMAT)
 339     .schema();
 340
 341 pub const HOSTNAME_SCHEMA: Schema = StringSchema::new("Hostname (as defined in RFC1123).")
 342     .format(&HOSTNAME_FORMAT)
 343     .schema();
 344
 345 pub const DNS_NAME_OR_IP_SCHEMA: Schema = StringSchema::new("DNS name or IP address.")
 346     .format(&DNS_NAME_OR_IP_FORMAT)
 347     .schema();
 348
 349 pub const BLOCKDEVICE_NAME_SCHEMA: Schema = StringSchema::new("Block device name (/sys/block/<name>).")
 350     .format(&BLOCKDEVICE_NAME_FORMAT)
 351     .min_length(3)
 352     .max_length(64)
 353     .schema();
 354
 355 // Complex type definitions
 356
 357 #[api(
 358     properties: {
 359         "backup-type": {
 360             schema: BACKUP_TYPE_SCHEMA,
 361         },
 362         "backup-id": {
 363             schema: BACKUP_ID_SCHEMA,
 364         },
 365         "last-backup": {
 366             schema: BACKUP_TIME_SCHEMA,
 367         },
 368         "backup-count": {
 369             type: Integer,
 370         },
 371         files: {
 372             items: {
 373                 schema: BACKUP_ARCHIVE_NAME_SCHEMA
 374             },
 375         },
 376         owner: {
 377             type: Userid,
 378             optional: true,
 379         },
 380     },
 381 )]
 382 #[derive(Serialize, Deserialize)]
 383 #[serde(rename_all="kebab-case")]
 384 /// Basic information about a backup group.
 385 pub struct GroupListItem {
 386     pub backup_type: String, // enum
 387     pub backup_id: String,
 388     pub last_backup: i64,
 389     /// Number of contained snapshots
 390     pub backup_count: u64,
 391     /// List of contained archive files.
 392     pub files: Vec<String>,
 393     /// The owner of group
 394     #[serde(skip_serializing_if="Option::is_none")]
 395     pub owner: Option<Userid>,
 396 }
 397
 398 #[api()]
 399 #[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
 400 #[serde(rename_all = "lowercase")]
 401 /// Result of a verify operation.
 402 pub enum VerifyState {
 403     /// Verification was successful
 404     Ok,
 405     /// Verification reported one or more errors
 406     Failed,
 407 }
 408
 409 #[api(
 410     properties: {
 411         upid: {
 412             schema: UPID_SCHEMA
 413         },
 414         state: {
 415             type: VerifyState
 416         },
 417     },
 418 )]
 419 #[derive(Serialize, Deserialize)]
 420 /// Task properties.
 421 pub struct SnapshotVerifyState {
 422     /// UPID of the verify task
 423     pub upid: UPID,
 424     /// State of the verification. Enum.
 425     pub state: VerifyState,
 426 }
 427
 428 #[api(
 429     properties: {
 430         "backup-type": {
 431             schema: BACKUP_TYPE_SCHEMA,
 432         },
 433         "backup-id": {
 434             schema: BACKUP_ID_SCHEMA,
 435         },
 436         "backup-time": {
 437             schema: BACKUP_TIME_SCHEMA,
 438         },
 439         comment: {
 440             schema: SINGLE_LINE_COMMENT_SCHEMA,
 441             optional: true,
 442         },
 443         verification: {
 444             type: SnapshotVerifyState,
 445             optional: true,
 446         },
 447         files: {
 448             items: {
 449                 schema: BACKUP_ARCHIVE_NAME_SCHEMA
 450             },
 451         },
 452         owner: {
 453             type: Userid,
 454             optional: true,
 455         },
 456     },
 457 )]
 458 #[derive(Serialize, Deserialize)]
 459 #[serde(rename_all="kebab-case")]
 460 /// Basic information about backup snapshot.
 461 pub struct SnapshotListItem {
 462     pub backup_type: String, // enum
 463     pub backup_id: String,
 464     pub backup_time: i64,
 465     /// The first line from manifest "notes"
 466     #[serde(skip_serializing_if="Option::is_none")]
 467     pub comment: Option<String>,
 468     /// The result of the last run verify task
 469     #[serde(skip_serializing_if="Option::is_none")]
 470     pub verification: Option<SnapshotVerifyState>,
 471     /// List of contained archive files.
 472     pub files: Vec<BackupContent>,
 473     /// Overall snapshot size (sum of all archive sizes).
 474     #[serde(skip_serializing_if="Option::is_none")]
 475     pub size: Option<u64>,
 476     /// The owner of the snapshots group
 477     #[serde(skip_serializing_if="Option::is_none")]
 478     pub owner: Option<Userid>,
 479 }
 480
 481 #[api(
 482     properties: {
 483         "backup-type": {
 484             schema: BACKUP_TYPE_SCHEMA,
 485         },
 486         "backup-id": {
 487             schema: BACKUP_ID_SCHEMA,
 488         },
 489         "backup-time": {
 490             schema: BACKUP_TIME_SCHEMA,
 491         },
 492     },
 493 )]
 494 #[derive(Serialize, Deserialize)]
 495 #[serde(rename_all="kebab-case")]
 496 /// Prune result.
 497 pub struct PruneListItem {
 498     pub backup_type: String, // enum
 499     pub backup_id: String,
 500     pub backup_time: i64,
 501     /// Keep snapshot
 502     pub keep: bool,
 503 }
 504
 505 pub const PRUNE_SCHEMA_KEEP_DAILY: Schema = IntegerSchema::new(
 506     "Number of daily backups to keep.")
 507     .minimum(1)
 508     .schema();
 509
 510 pub const PRUNE_SCHEMA_KEEP_HOURLY: Schema = IntegerSchema::new(
 511     "Number of hourly backups to keep.")
 512     .minimum(1)
 513     .schema();
 514
 515 pub const PRUNE_SCHEMA_KEEP_LAST: Schema = IntegerSchema::new(
 516     "Number of backups to keep.")
 517     .minimum(1)
 518     .schema();
 519
 520 pub const PRUNE_SCHEMA_KEEP_MONTHLY: Schema = IntegerSchema::new(
 521     "Number of monthly backups to keep.")
 522     .minimum(1)
 523     .schema();
 524
 525 pub const PRUNE_SCHEMA_KEEP_WEEKLY: Schema = IntegerSchema::new(
 526     "Number of weekly backups to keep.")
 527     .minimum(1)
 528     .schema();
 529
 530 pub const PRUNE_SCHEMA_KEEP_YEARLY: Schema = IntegerSchema::new(
 531     "Number of yearly backups to keep.")
 532     .minimum(1)
 533     .schema();
 534
 535 #[api(
 536     properties: {
 537         "filename": {
 538             schema: BACKUP_ARCHIVE_NAME_SCHEMA,
 539         },
 540         "crypt-mode": {
 541             type: CryptMode,
 542             optional: true,
 543         },
 544     },
 545 )]
 546 #[derive(Serialize, Deserialize)]
 547 #[serde(rename_all="kebab-case")]
 548 /// Basic information about archive files inside a backup snapshot.
 549 pub struct BackupContent {
 550     pub filename: String,
 551     /// Info if file is encrypted, signed, or neither.
 552     #[serde(skip_serializing_if="Option::is_none")]
 553     pub crypt_mode: Option<CryptMode>,
 554     /// Archive size (from backup manifest).
 555     #[serde(skip_serializing_if="Option::is_none")]
 556     pub size: Option<u64>,
 557 }
 558
 559 #[api(
 560     properties: {
 561         "upid": {
 562             optional: true,
 563             schema: UPID_SCHEMA,
 564         },
 565     },
 566 )]
 567 #[derive(Clone, Serialize, Deserialize)]
 568 #[serde(rename_all="kebab-case")]
 569 /// Garbage collection status.
 570 pub struct GarbageCollectionStatus {
 571     pub upid: Option<String>,
 572     /// Number of processed index files.
 573     pub index_file_count: usize,
 574     /// Sum of bytes referred by index files.
 575     pub index_data_bytes: u64,
 576     /// Bytes used on disk.
 577     pub disk_bytes: u64,
 578     /// Chunks used on disk.
 579     pub disk_chunks: usize,
 580     /// Sum of removed bytes.
 581     pub removed_bytes: u64,
 582     /// Number of removed chunks.
 583     pub removed_chunks: usize,
 584     /// Sum of pending bytes (pending removal - kept for safety).
 585     pub pending_bytes: u64,
 586     /// Number of pending chunks (pending removal - kept for safety).
 587     pub pending_chunks: usize,
 588     /// Number of chunks marked as .bad by verify that have been removed by GC.
 589     pub removed_bad: usize,
 590     /// Number of chunks still marked as .bad after garbage collection.
 591     pub still_bad: usize,
 592 }
 593
 594 impl Default for GarbageCollectionStatus {
 595     fn default() -> Self {
 596         GarbageCollectionStatus {
 597             upid: None,
 598             index_file_count: 0,
 599             index_data_bytes: 0,
 600             disk_bytes: 0,
 601             disk_chunks: 0,
 602             removed_bytes: 0,
 603             removed_chunks: 0,
 604             pending_bytes: 0,
 605             pending_chunks: 0,
 606             removed_bad: 0,
 607             still_bad: 0,
 608         }
 609     }
 610 }
 611
 612
 613 #[api()]
 614 #[derive(Serialize, Deserialize)]
 615 /// Storage space usage information.
 616 pub struct StorageStatus {
 617     /// Total space (bytes).
 618     pub total: u64,
 619     /// Used space (bytes).
 620     pub used: u64,
 621     /// Available space (bytes).
 622     pub avail: u64,
 623 }
 624
 625 #[api()]
 626 #[derive(Serialize, Deserialize, Default)]
 627 /// Backup Type group/snapshot counts.
 628 pub struct TypeCounts {
 629     /// The number of groups of the type.
 630     pub groups: u64,
 631     /// The number of snapshots of the type.
 632     pub snapshots: u64,
 633 }
 634
 635 #[api(
 636     properties: {
 637         ct: {
 638             type: TypeCounts,
 639             optional: true,
 640         },
 641         host: {
 642             type: TypeCounts,
 643             optional: true,
 644         },
 645         vm: {
 646             type: TypeCounts,
 647             optional: true,
 648         },
 649         other: {
 650             type: TypeCounts,
 651             optional: true,
 652         },
 653     },
 654 )]
 655 #[derive(Serialize, Deserialize)]
 656 /// Counts of groups/snapshots per BackupType.
 657 pub struct Counts {
 658     /// The counts for CT backups
 659     pub ct: Option<TypeCounts>,
 660     /// The counts for Host backups
 661     pub host: Option<TypeCounts>,
 662     /// The counts for VM backups
 663     pub vm: Option<TypeCounts>,
 664     /// The counts for other backup types
 665     pub other: Option<TypeCounts>,
 666 }
 667
 668 #[api(
 669     properties: {
 670         "gc-status": { type: GarbageCollectionStatus, },
 671         counts: { type: Counts, }
 672     },
 673 )]
 674 #[derive(Serialize, Deserialize)]
 675 #[serde(rename_all="kebab-case")]
 676 /// Overall Datastore status and useful information.
 677 pub struct DataStoreStatus {
 678     /// Total space (bytes).
 679     pub total: u64,
 680     /// Used space (bytes).
 681     pub used: u64,
 682     /// Available space (bytes).
 683     pub avail: u64,
 684     /// Status of last GC
 685     pub gc_status: GarbageCollectionStatus,
 686     /// Group/Snapshot counts
 687     pub counts: Counts,
 688 }
 689
 690 #[api(
 691     properties: {
 692         upid: { schema: UPID_SCHEMA },
 693         user: { type: Userid },
 694     },
 695 )]
 696 #[derive(Serialize, Deserialize)]
 697 /// Task properties.
 698 pub struct TaskListItem {
 699     pub upid: String,
 700     /// The node name where the task is running on.
 701     pub node: String,
 702     /// The Unix PID
 703     pub pid: i64,
 704     /// The task start time (Epoch)
 705     pub pstart: u64,
 706     /// The task start time (Epoch)
 707     pub starttime: i64,
 708     /// Worker type (arbitrary ASCII string)
 709     pub worker_type: String,
 710     /// Worker ID (arbitrary ASCII string)
 711     pub worker_id: Option<String>,
 712     /// The user who started the task
 713     pub user: Userid,
 714     /// The task end time (Epoch)
 715     #[serde(skip_serializing_if="Option::is_none")]
 716     pub endtime: Option<i64>,
 717     /// Task end status
 718     #[serde(skip_serializing_if="Option::is_none")]
 719     pub status: Option<String>,
 720 }
 721
 722 impl From<crate::server::TaskListInfo> for TaskListItem {
 723     fn from(info: crate::server::TaskListInfo) -> Self {
 724         let (endtime, status) = info
 725             .state
 726             .map_or_else(|| (None, None), |a| (Some(a.endtime()), Some(a.to_string())));
 727
 728         TaskListItem {
 729             upid: info.upid_str,
 730             node: "localhost".to_string(),
 731             pid: info.upid.pid as i64,
 732             pstart: info.upid.pstart,
 733             starttime: info.upid.starttime,
 734             worker_type: info.upid.worker_type,
 735             worker_id: info.upid.worker_id,
 736             user: info.upid.userid,
 737             endtime,
 738             status,
 739         }
 740     }
 741 }
 742
 743 #[api()]
 744 #[derive(Eq, PartialEq, Debug, Serialize, Deserialize)]
 745 #[serde(rename_all = "lowercase")]
 746 pub enum TaskStateType {
 747     /// Ok
 748     OK,
 749     /// Warning
 750     Warning,
 751     /// Error
 752     Error,
 753     /// Unknown
 754     Unknown,
 755 }
 756
 757 #[api()]
 758 #[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
 759 #[serde(rename_all = "lowercase")]
 760 /// Node Power command type.
 761 pub enum NodePowerCommand {
 762     /// Restart the server
 763     Reboot,
 764     /// Shutdown the server
 765     Shutdown,
 766 }
 767
 768 #[api()]
 769 #[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
 770 #[serde(rename_all = "lowercase")]
 771 /// Interface configuration method
 772 pub enum NetworkConfigMethod {
 773     /// Configuration is done manually using other tools
 774     Manual,
 775     /// Define interfaces with statically allocated addresses.
 776     Static,
 777     /// Obtain an address via DHCP
 778     DHCP,
 779     /// Define the loopback interface.
 780     Loopback,
 781 }
 782
 783 #[api()]
 784 #[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
 785 #[serde(rename_all = "kebab-case")]
 786 #[allow(non_camel_case_types)]
 787 #[repr(u8)]
 788 /// Linux Bond Mode
 789 pub enum LinuxBondMode {
 790     /// Round-robin policy
 791     balance_rr = 0,
 792     /// Active-backup policy
 793     active_backup = 1,
 794     /// XOR policy
 795     balance_xor = 2,
 796     /// Broadcast policy
 797     broadcast = 3,
 798     /// IEEE 802.3ad Dynamic link aggregation
 799     #[serde(rename = "802.3ad")]
 800     ieee802_3ad = 4,
 801     /// Adaptive transmit load balancing
 802     balance_tlb = 5,
 803     /// Adaptive load balancing
 804     balance_alb = 6,
 805 }
 806
 807 #[api()]
 808 #[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
 809 #[serde(rename_all = "kebab-case")]
 810 #[allow(non_camel_case_types)]
 811 #[repr(u8)]
 812 /// Bond Transmit Hash Policy for LACP (802.3ad)
 813 pub enum BondXmitHashPolicy {
 814     /// Layer 2
 815     layer2 = 0,
 816     /// Layer 2+3
 817     #[serde(rename = "layer2+3")]
 818     layer2_3 = 1,
 819     /// Layer 3+4
 820     #[serde(rename = "layer3+4")]
 821     layer3_4 = 2,
 822 }
 823
 824 #[api()]
 825 #[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
 826 #[serde(rename_all = "lowercase")]
 827 /// Network interface type
 828 pub enum NetworkInterfaceType {
 829     /// Loopback
 830     Loopback,
 831     /// Physical Ethernet device
 832     Eth,
 833     /// Linux Bridge
 834     Bridge,
 835     /// Linux Bond
 836     Bond,
 837     /// Linux VLAN (eth.10)
 838     Vlan,
 839     /// Interface Alias (eth:1)
 840     Alias,
 841     /// Unknown interface type
 842     Unknown,
 843 }
 844
 845 pub const NETWORK_INTERFACE_NAME_SCHEMA: Schema = StringSchema::new("Network interface name.")
 846     .format(&NETWORK_INTERFACE_FORMAT)
 847     .min_length(1)
 848     .max_length(libc::IFNAMSIZ-1)
 849     .schema();
 850
 851 pub const NETWORK_INTERFACE_ARRAY_SCHEMA: Schema = ArraySchema::new(
 852     "Network interface list.", &NETWORK_INTERFACE_NAME_SCHEMA)
 853     .schema();
 854
 855 pub const NETWORK_INTERFACE_LIST_SCHEMA: Schema = StringSchema::new(
 856     "A list of network devices, comma separated.")
 857     .format(&ApiStringFormat::PropertyString(&NETWORK_INTERFACE_ARRAY_SCHEMA))
 858     .schema();
 859
 860 #[api(
 861     properties: {
 862         name: {
 863             schema: NETWORK_INTERFACE_NAME_SCHEMA,
 864         },
 865         "type": {
 866             type: NetworkInterfaceType,
 867         },
 868         method: {
 869             type: NetworkConfigMethod,
 870             optional: true,
 871         },
 872         method6: {
 873             type: NetworkConfigMethod,
 874             optional: true,
 875         },
 876         cidr: {
 877             schema: CIDR_V4_SCHEMA,
 878             optional: true,
 879         },
 880         cidr6: {
 881             schema: CIDR_V6_SCHEMA,
 882             optional: true,
 883         },
 884         gateway: {
 885             schema: IP_V4_SCHEMA,
 886             optional: true,
 887         },
 888         gateway6: {
 889             schema: IP_V6_SCHEMA,
 890             optional: true,
 891         },
 892         options: {
 893             description: "Option list (inet)",
 894             type: Array,
 895             items: {
 896                 description: "Optional attribute line.",
 897                 type: String,
 898             },
 899         },
 900         options6: {
 901             description: "Option list (inet6)",
 902             type: Array,
 903             items: {
 904                 description: "Optional attribute line.",
 905                 type: String,
 906             },
 907         },
 908         comments: {
 909             description: "Comments (inet, may span multiple lines)",
 910             type: String,
 911             optional: true,
 912         },
 913         comments6: {
 914             description: "Comments (inet6, may span multiple lines)",
 915             type: String,
 916             optional: true,
 917         },
 918         bridge_ports: {
 919             schema: NETWORK_INTERFACE_ARRAY_SCHEMA,
 920             optional: true,
 921         },
 922         slaves: {
 923             schema: NETWORK_INTERFACE_ARRAY_SCHEMA,
 924             optional: true,
 925         },
 926         bond_mode: {
 927             type: LinuxBondMode,
 928             optional: true,
 929         },
 930         "bond-primary": {
 931             schema: NETWORK_INTERFACE_NAME_SCHEMA,
 932             optional: true,
 933         },
 934         bond_xmit_hash_policy: {
 935             type: BondXmitHashPolicy,
 936             optional: true,
 937         },
 938     }
 939 )]
 940 #[derive(Debug, Serialize, Deserialize)]
 941 /// Network Interface configuration
 942 pub struct Interface {
 943     /// Autostart interface
 944     #[serde(rename = "autostart")]
 945     pub autostart: bool,
 946     /// Interface is active (UP)
 947     pub active: bool,
 948     /// Interface name
 949     pub name: String,
 950     /// Interface type
 951     #[serde(rename = "type")]
 952     pub interface_type: NetworkInterfaceType,
 953     #[serde(skip_serializing_if="Option::is_none")]
 954     pub method: Option<NetworkConfigMethod>,
 955     #[serde(skip_serializing_if="Option::is_none")]
 956     pub method6: Option<NetworkConfigMethod>,
 957     #[serde(skip_serializing_if="Option::is_none")]
 958     /// IPv4 address with netmask
 959     pub cidr: Option<String>,
 960     #[serde(skip_serializing_if="Option::is_none")]
 961     /// IPv4 gateway
 962     pub gateway: Option<String>,
 963     #[serde(skip_serializing_if="Option::is_none")]
 964     /// IPv6 address with netmask
 965     pub cidr6: Option<String>,
 966     #[serde(skip_serializing_if="Option::is_none")]
 967     /// IPv6 gateway
 968     pub gateway6: Option<String>,
 969
 970     #[serde(skip_serializing_if="Vec::is_empty")]
 971     pub options: Vec<String>,
 972     #[serde(skip_serializing_if="Vec::is_empty")]
 973     pub options6: Vec<String>,
 974
 975     #[serde(skip_serializing_if="Option::is_none")]
 976     pub comments: Option<String>,
 977     #[serde(skip_serializing_if="Option::is_none")]
 978     pub comments6: Option<String>,
 979
 980     #[serde(skip_serializing_if="Option::is_none")]
 981     /// Maximum Transmission Unit
 982     pub mtu: Option<u64>,
 983
 984     #[serde(skip_serializing_if="Option::is_none")]
 985     pub bridge_ports: Option<Vec<String>>,
 986     /// Enable bridge vlan support.
 987     #[serde(skip_serializing_if="Option::is_none")]
 988     pub bridge_vlan_aware: Option<bool>,
 989
 990     #[serde(skip_serializing_if="Option::is_none")]
 991     pub slaves: Option<Vec<String>>,
 992     #[serde(skip_serializing_if="Option::is_none")]
 993     pub bond_mode: Option<LinuxBondMode>,
 994     #[serde(skip_serializing_if="Option::is_none")]
 995     #[serde(rename = "bond-primary")]
 996     pub bond_primary: Option<String>,
 997     pub bond_xmit_hash_policy: Option<BondXmitHashPolicy>,
 998 }
 999
1000 // Regression tests
1001
1002 #[test]
1003 fn test_cert_fingerprint_schema() -> Result<(), anyhow::Error> {
1004
1005     let schema = CERT_FINGERPRINT_SHA256_SCHEMA;
1006
1007     let invalid_fingerprints = [
1008         "86:88:7c:be:26:77:a5:62:67:d9:06:f5:e4::61:3e:20:dc:cd:43:92:07:7f:fb:65:54:6c:ff:d2:96:36:f8",
1009         "88:7C:BE:26:77:a5:62:67:D9:06:f5:e4:14:61:3e:20:dc:cd:43:92:07:7f:fb:65:54:6c:ff:d2:96:36:f8",
1010         "86:88:7c:be:26:77:a5:62:67:d9:06:f5:e4::14:61:3e:20:dc:cd:43:92:07:7f:fb:65:54:6c:ff:d2:96:36:f8:ff",
1011         "XX:88:7c:be:26:77:a5:62:67:d9:06:f5:e4::14:61:3e:20:dc:cd:43:92:07:7f:fb:65:54:6c:ff:d2:96:36:f8",
1012         "86:88:Y4:be:26:77:a5:62:67:d9:06:f5:e4:14:61:3e:20:dc:cd:43:92:07:7f:fb:65:54:6c:ff:d2:96:36:f8",
1013         "86:88:0:be:26:77:a5:62:67:d9:06:f5:e4:14:61:3e:20:dc:cd:43:92:07:7f:fb:65:54:6c:ff:d2:96:36:f8",
1014     ];
1015
1016     for fingerprint in invalid_fingerprints.iter() {
1017         if let Ok(_) = parse_simple_value(fingerprint, &schema) {
1018             bail!("test fingerprint '{}' failed -  got Ok() while exception an error.", fingerprint);
1019         }
1020     }
1021
1022     let valid_fingerprints = [
1023         "86:88:7c:be:26:77:a5:62:67:d9:06:f5:e4:14:61:3e:20:dc:cd:43:92:07:7f:fb:65:54:6c:ff:d2:96:36:f8",
1024         "86:88:7C:BE:26:77:a5:62:67:D9:06:f5:e4:14:61:3e:20:dc:cd:43:92:07:7f:fb:65:54:6c:ff:d2:96:36:f8",
1025     ];
1026
1027     for fingerprint in valid_fingerprints.iter() {
1028         let v = match parse_simple_value(fingerprint, &schema) {
1029             Ok(v) => v,
1030             Err(err) => {
1031                 bail!("unable to parse fingerprint '{}' - {}", fingerprint, err);
1032             }
1033         };
1034
1035         if v != serde_json::json!(fingerprint) {
1036             bail!("unable to parse fingerprint '{}' - got wrong value {:?}", fingerprint, v);
1037         }
1038     }
1039
1040     Ok(())
1041 }
1042
1043 #[test]
1044 fn test_proxmox_user_id_schema() -> Result<(), anyhow::Error> {
1045     let invalid_user_ids = [
1046         "x", // too short
1047         "xx", // too short
1048         "xxx", // no realm
1049         "xxx@", // no realm
1050         "xx x@test", // contains space
1051         "xx\nx@test", // contains control character
1052         "x:xx@test", // contains collon
1053         "xx/x@test", // contains slash
1054         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx@test", // too long
1055     ];
1056
1057     for name in invalid_user_ids.iter() {
1058         if let Ok(_) = parse_simple_value(name, &Userid::API_SCHEMA) {
1059             bail!("test userid '{}' failed -  got Ok() while exception an error.", name);
1060         }
1061     }
1062
1063     let valid_user_ids = [
1064         "xxx@y",
1065         "name@y",
1066         "xxx@test-it.com",
1067         "xxx@_T_E_S_T-it.com",
1068         "x_x-x.x@test-it.com",
1069     ];
1070
1071     for name in valid_user_ids.iter() {
1072         let v = match parse_simple_value(name, &Userid::API_SCHEMA) {
1073             Ok(v) => v,
1074             Err(err) => {
1075                 bail!("unable to parse userid '{}' - {}", name, err);
1076             }
1077         };
1078
1079         if v != serde_json::json!(name) {
1080             bail!("unable to parse userid '{}' - got wrong value {:?}", name, v);
1081         }
1082     }
1083
1084     Ok(())
1085 }
1086
1087 #[api()]
1088 #[derive(Copy, Clone, Serialize, Deserialize)]
1089 #[serde(rename_all = "UPPERCASE")]
1090 pub enum RRDMode {
1091     /// Maximum
1092     Max,
1093     /// Average
1094     Average,
1095 }
1096
1097
1098 #[api()]
1099 #[repr(u64)]
1100 #[derive(Copy, Clone, Serialize, Deserialize)]
1101 #[serde(rename_all = "lowercase")]
1102 pub enum RRDTimeFrameResolution {
1103     ///  1 min => last 70 minutes
1104     Hour = 60,
1105     /// 30 min => last 35 hours
1106     Day = 60*30,
1107     /// 3 hours => about 8 days
1108     Week = 60*180,
1109     /// 12 hours => last 35 days
1110     Month = 60*720,
1111     /// 1 week => last 490 days
1112     Year = 60*10080,
1113 }
1114
1115 #[api()]
1116 #[derive(Serialize, Deserialize)]
1117 #[serde(rename_all = "PascalCase")]
1118 /// Describes a package for which an update is available.
1119 pub struct APTUpdateInfo {
1120     /// Package name
1121     pub package: String,
1122     /// Package title
1123     pub title: String,
1124     /// Package architecture
1125     pub arch: String,
1126     /// Human readable package description
1127     pub description: String,
1128     /// New version to be updated to
1129     pub version: String,
1130     /// Old version currently installed
1131     pub old_version: String,
1132     /// Package origin
1133     pub origin: String,
1134     /// Package priority in human-readable form
1135     pub priority: String,
1136     /// Package section
1137     pub section: String,
1138     /// URL under which the package's changelog can be retrieved
1139     pub change_log_url: String,
1140 }