2 use ::serde
::{Deserialize, Serialize}
;
4 use proxmox
::api
::{api, schema::*}
;
5 use proxmox
::const_regex
;
6 use proxmox
::{IPRE, IPV4RE, IPV6RE, IPV4OCTET, IPV6H16, IPV6LS32}
;
8 // File names: may not contain slashes, may not start with "."
9 pub const FILENAME_FORMAT
: ApiStringFormat
= ApiStringFormat
::VerifyFn(|name
| {
10 if name
.starts_with('
.'
) {
11 bail
!("file names may not start with '.'");
13 if name
.contains('
/'
) {
14 bail
!("file names may not contain slashes");
19 macro_rules
! DNS_LABEL { () => (r"(?:[a-zA-Z0-9](?:[a-zA-Z0-9\-]*[a-zA-Z0-9])?)") }
20 macro_rules
! DNS_NAME { () => (concat!(r"(?:", DNS_LABEL!() , r"\.)*", DNS_LABEL!())) }
22 // we only allow a limited set of characters
23 // colon is not allowed, because we store usernames in
24 // colon separated lists)!
25 // slash is not allowed because it is used as pve API delimiter
26 // also see "man useradd"
27 macro_rules
! USER_NAME_REGEX_STR { () => (r"(?:[^\s:/[:cntrl:]]+)") }
28 macro_rules
! GROUP_NAME_REGEX_STR { () => (USER_NAME_REGEX_STR!()) }
30 macro_rules
! PROXMOX_SAFE_ID_REGEX_STR { () => (r"(?:[A-Za-z0-9_][A-Za-z0-9._\-]*)") }
32 macro_rules
! CIDR_V4_REGEX_STR { () => (concat!(r"(?:", IPV4RE!(), r"/\d{1,2}
)$
")) }
33 macro_rules! CIDR_V6_REGEX_STR { () => (concat!(r"(?:", IPV6RE!(), r"/\d{1,3})$")) }
36 pub IP_V4_REGEX
= concat
!(r
"^", IPV4RE
!(), r
"$");
37 pub IP_V6_REGEX
= concat
!(r
"^", IPV6RE
!(), r
"$");
38 pub IP_REGEX
= concat
!(r
"^", IPRE
!(), r
"$");
39 pub CIDR_V4_REGEX
= concat
!(r
"^", CIDR_V4_REGEX_STR
!(), r
"$");
40 pub CIDR_V6_REGEX
= concat
!(r
"^", CIDR_V6_REGEX_STR
!(), r
"$");
41 pub CIDR_REGEX
= concat
!(r
"^(?:", CIDR_V4_REGEX_STR
!(), "|", CIDR_V6_REGEX_STR
!(), r
")$");
43 pub SHA256_HEX_REGEX
= r
"^[a-f0-9]{64}$"; // fixme: define in common_regex ?
44 pub SYSTEMD_DATETIME_REGEX
= r
"^\d{4}-\d{2}-\d{2}( \d{2}:\d{2}(:\d{2})?)?$"; // fixme: define in common_regex ?
46 pub PASSWORD_REGEX
= r
"^[[:^cntrl:]]*$"; // everything but control characters
48 /// Regex for safe identifiers.
51 /// [article](https://dwheeler.com/essays/fixing-unix-linux-filenames.html)
52 /// contains further information why it is reasonable to restict
53 /// names this way. This is not only useful for filenames, but for
54 /// any identifier command line tools work with.
55 pub PROXMOX_SAFE_ID_REGEX
= concat
!(r
"^", PROXMOX_SAFE_ID_REGEX_STR
!(), r
"$");
57 pub SINGLE_LINE_COMMENT_REGEX
= r
"^[[:^cntrl:]]*$";
59 pub HOSTNAME_REGEX
= r
"^(?:[a-zA-Z0-9](?:[a-zA-Z0-9\-]*[a-zA-Z0-9])?)$";
61 pub DNS_NAME_REGEX
= concat
!(r
"^", DNS_NAME
!(), r
"$");
63 pub DNS_NAME_OR_IP_REGEX
= concat
!(r
"^", DNS_NAME
!(), "|", IPRE
!(), r
"$");
65 pub PROXMOX_USER_ID_REGEX
= concat
!(r
"^", USER_NAME_REGEX_STR
!(), r
"@", PROXMOX_SAFE_ID_REGEX_STR
!(), r
"$");
67 pub PROXMOX_GROUP_ID_REGEX
= concat
!(r
"^", GROUP_NAME_REGEX_STR
!(), r
"$");
69 pub CERT_FINGERPRINT_SHA256_REGEX
= r
"^(?:[0-9a-fA-F][0-9a-fA-F])(?::[0-9a-fA-F][0-9a-fA-F]){31}$";
71 pub ACL_PATH_REGEX
= concat
!(r
"^(?:/|", r
"(?:/", PROXMOX_SAFE_ID_REGEX_STR
!(), ")+", r
")$");
74 pub const SYSTEMD_DATETIME_FORMAT
: ApiStringFormat
=
75 ApiStringFormat
::Pattern(&SYSTEMD_DATETIME_REGEX
);
77 pub const IP_V4_FORMAT
: ApiStringFormat
=
78 ApiStringFormat
::Pattern(&IP_V4_REGEX
);
80 pub const IP_V6_FORMAT
: ApiStringFormat
=
81 ApiStringFormat
::Pattern(&IP_V6_REGEX
);
83 pub const IP_FORMAT
: ApiStringFormat
=
84 ApiStringFormat
::Pattern(&IP_REGEX
);
86 pub const PVE_CONFIG_DIGEST_FORMAT
: ApiStringFormat
=
87 ApiStringFormat
::Pattern(&SHA256_HEX_REGEX
);
89 pub const CERT_FINGERPRINT_SHA256_FORMAT
: ApiStringFormat
=
90 ApiStringFormat
::Pattern(&CERT_FINGERPRINT_SHA256_REGEX
);
92 pub const PROXMOX_SAFE_ID_FORMAT
: ApiStringFormat
=
93 ApiStringFormat
::Pattern(&PROXMOX_SAFE_ID_REGEX
);
95 pub const SINGLE_LINE_COMMENT_FORMAT
: ApiStringFormat
=
96 ApiStringFormat
::Pattern(&SINGLE_LINE_COMMENT_REGEX
);
98 pub const HOSTNAME_FORMAT
: ApiStringFormat
=
99 ApiStringFormat
::Pattern(&HOSTNAME_REGEX
);
101 pub const DNS_NAME_FORMAT
: ApiStringFormat
=
102 ApiStringFormat
::Pattern(&DNS_NAME_REGEX
);
104 pub const DNS_NAME_OR_IP_FORMAT
: ApiStringFormat
=
105 ApiStringFormat
::Pattern(&DNS_NAME_OR_IP_REGEX
);
107 pub const PROXMOX_USER_ID_FORMAT
: ApiStringFormat
=
108 ApiStringFormat
::Pattern(&PROXMOX_USER_ID_REGEX
);
110 pub const PROXMOX_GROUP_ID_FORMAT
: ApiStringFormat
=
111 ApiStringFormat
::Pattern(&PROXMOX_GROUP_ID_REGEX
);
113 pub const PASSWORD_FORMAT
: ApiStringFormat
=
114 ApiStringFormat
::Pattern(&PASSWORD_REGEX
);
116 pub const ACL_PATH_FORMAT
: ApiStringFormat
=
117 ApiStringFormat
::Pattern(&ACL_PATH_REGEX
);
119 pub const NETWORK_INTERFACE_FORMAT
: ApiStringFormat
=
120 ApiStringFormat
::Pattern(&PROXMOX_SAFE_ID_REGEX
);
122 pub const CIDR_V4_FORMAT
: ApiStringFormat
=
123 ApiStringFormat
::Pattern(&CIDR_V4_REGEX
);
125 pub const CIDR_V6_FORMAT
: ApiStringFormat
=
126 ApiStringFormat
::Pattern(&CIDR_V6_REGEX
);
128 pub const CIDR_FORMAT
: ApiStringFormat
=
129 ApiStringFormat
::Pattern(&CIDR_REGEX
);
132 pub const PASSWORD_SCHEMA
: Schema
= StringSchema
::new("Password.")
133 .format(&PASSWORD_FORMAT
)
138 pub const PBS_PASSWORD_SCHEMA
: Schema
= StringSchema
::new("User Password.")
139 .format(&PASSWORD_FORMAT
)
144 pub const CERT_FINGERPRINT_SHA256_SCHEMA
: Schema
= StringSchema
::new(
145 "X509 certificate fingerprint (sha256)."
147 .format(&CERT_FINGERPRINT_SHA256_FORMAT
)
150 pub const PROXMOX_CONFIG_DIGEST_SCHEMA
: Schema
= StringSchema
::new(r
#"\
151 Prevent changes if current configuration file has different SHA256 digest.
152 This can be used to prevent concurrent modifications.
155 .format(&PVE_CONFIG_DIGEST_FORMAT
)
159 pub const CHUNK_DIGEST_FORMAT
: ApiStringFormat
=
160 ApiStringFormat
::Pattern(&SHA256_HEX_REGEX
);
162 pub const CHUNK_DIGEST_SCHEMA
: Schema
= StringSchema
::new("Chunk digest (SHA256).")
163 .format(&CHUNK_DIGEST_FORMAT
)
166 pub const NODE_SCHEMA
: Schema
= StringSchema
::new("Node name (or 'localhost')")
167 .format(&ApiStringFormat
::VerifyFn(|node
| {
168 if node
== "localhost" || node
== proxmox
::tools
::nodename() {
171 bail
!("no such node '{}'", node
);
176 pub const SEARCH_DOMAIN_SCHEMA
: Schema
=
177 StringSchema
::new("Search domain for host-name lookup.").schema();
179 pub const FIRST_DNS_SERVER_SCHEMA
: Schema
=
180 StringSchema
::new("First name server IP address.")
184 pub const SECOND_DNS_SERVER_SCHEMA
: Schema
=
185 StringSchema
::new("Second name server IP address.")
189 pub const THIRD_DNS_SERVER_SCHEMA
: Schema
=
190 StringSchema
::new("Third name server IP address.")
194 pub const IP_V4_SCHEMA
: Schema
=
195 StringSchema
::new("IPv4 address.")
196 .format(&IP_V4_FORMAT
)
200 pub const IP_V6_SCHEMA
: Schema
=
201 StringSchema
::new("IPv6 address.")
202 .format(&IP_V6_FORMAT
)
206 pub const IP_SCHEMA
: Schema
=
207 StringSchema
::new("IP (IPv4 or IPv6) address.")
212 pub const CIDR_V4_SCHEMA
: Schema
=
213 StringSchema
::new("IPv4 address with netmask (CIDR notation).")
214 .format(&CIDR_V4_FORMAT
)
218 pub const CIDR_V6_SCHEMA
: Schema
=
219 StringSchema
::new("IPv6 address with netmask (CIDR notation).")
220 .format(&CIDR_V6_FORMAT
)
224 pub const CIDR_SCHEMA
: Schema
=
225 StringSchema
::new("IP address (IPv4 or IPv6) with netmask (CIDR notation).")
226 .format(&CIDR_FORMAT
)
230 pub const TIME_ZONE_SCHEMA
: Schema
= StringSchema
::new(
231 "Time zone. The file '/usr/share/zoneinfo/zone.tab' contains the list of valid names.")
232 .format(&SINGLE_LINE_COMMENT_FORMAT
)
237 pub const ACL_PATH_SCHEMA
: Schema
= StringSchema
::new(
238 "Access control path.")
239 .format(&ACL_PATH_FORMAT
)
244 pub const ACL_PROPAGATE_SCHEMA
: Schema
= BooleanSchema
::new(
245 "Allow to propagate (inherit) permissions.")
249 pub const ACL_UGID_TYPE_SCHEMA
: Schema
= StringSchema
::new(
250 "Type of 'ugid' property.")
251 .format(&ApiStringFormat
::Enum(&["user", "group"]))
254 pub const ACL_ROLE_SCHEMA
: Schema
= StringSchema
::new(
256 .format(&ApiStringFormat
::Enum(&[
266 pub const BACKUP_ARCHIVE_NAME_SCHEMA
: Schema
=
267 StringSchema
::new("Backup archive name.")
268 .format(&PROXMOX_SAFE_ID_FORMAT
)
271 pub const BACKUP_TYPE_SCHEMA
: Schema
=
272 StringSchema
::new("Backup type.")
273 .format(&ApiStringFormat
::Enum(&["vm", "ct", "host"]))
276 pub const BACKUP_ID_SCHEMA
: Schema
=
277 StringSchema
::new("Backup ID.")
278 .format(&PROXMOX_SAFE_ID_FORMAT
)
281 pub const BACKUP_TIME_SCHEMA
: Schema
=
282 IntegerSchema
::new("Backup time (Unix epoch.)")
283 .minimum(1_547_797_308)
286 pub const UPID_SCHEMA
: Schema
= StringSchema
::new("Unique Process/Task ID.")
290 pub const DATASTORE_SCHEMA
: Schema
= StringSchema
::new("Datastore name.")
291 .format(&PROXMOX_SAFE_ID_FORMAT
)
296 pub const REMOTE_ID_SCHEMA
: Schema
= StringSchema
::new("Remote ID.")
297 .format(&PROXMOX_SAFE_ID_FORMAT
)
302 pub const SINGLE_LINE_COMMENT_SCHEMA
: Schema
= StringSchema
::new("Comment (single line).")
303 .format(&SINGLE_LINE_COMMENT_FORMAT
)
306 pub const HOSTNAME_SCHEMA
: Schema
= StringSchema
::new("Hostname (as defined in RFC1123).")
307 .format(&HOSTNAME_FORMAT
)
310 pub const DNS_NAME_OR_IP_SCHEMA
: Schema
= StringSchema
::new("DNS name or IP address.")
311 .format(&DNS_NAME_OR_IP_FORMAT
)
314 pub const PROXMOX_AUTH_REALM_SCHEMA
: Schema
= StringSchema
::new("Authentication domain ID")
315 .format(&PROXMOX_SAFE_ID_FORMAT
)
320 pub const PROXMOX_USER_ID_SCHEMA
: Schema
= StringSchema
::new("User ID")
321 .format(&PROXMOX_USER_ID_FORMAT
)
326 pub const PROXMOX_GROUP_ID_SCHEMA
: Schema
= StringSchema
::new("Group ID")
327 .format(&PROXMOX_GROUP_ID_FORMAT
)
333 // Complex type definitions
338 schema
: BACKUP_TYPE_SCHEMA
,
341 schema
: BACKUP_ID_SCHEMA
,
344 schema
: BACKUP_TIME_SCHEMA
,
351 schema
: BACKUP_ARCHIVE_NAME_SCHEMA
356 #[derive(Serialize, Deserialize)]
357 #[serde(rename_all="kebab-case")]
358 /// Basic information about a backup group.
359 pub struct GroupListItem
{
360 pub backup_type
: String
, // enum
361 pub backup_id
: String
,
362 pub last_backup
: i64,
363 /// Number of contained snapshots
364 pub backup_count
: u64,
365 /// List of contained archive files.
366 pub files
: Vec
<String
>,
372 schema
: BACKUP_TYPE_SCHEMA
,
375 schema
: BACKUP_ID_SCHEMA
,
378 schema
: BACKUP_TIME_SCHEMA
,
382 schema
: BACKUP_ARCHIVE_NAME_SCHEMA
387 #[derive(Serialize, Deserialize)]
388 #[serde(rename_all="kebab-case")]
389 /// Basic information about backup snapshot.
390 pub struct SnapshotListItem
{
391 pub backup_type
: String
, // enum
392 pub backup_id
: String
,
393 pub backup_time
: i64,
394 /// List of contained archive files.
395 pub files
: Vec
<String
>,
396 /// Overall snapshot size (sum of all archive sizes).
397 #[serde(skip_serializing_if="Option::is_none")]
398 pub size
: Option
<u64>,
404 schema
: BACKUP_ARCHIVE_NAME_SCHEMA
,
408 #[derive(Serialize, Deserialize)]
409 #[serde(rename_all="kebab-case")]
410 /// Basic information about archive files inside a backup snapshot.
411 pub struct BackupContent
{
412 pub filename
: String
,
413 /// Archive size (from backup manifest).
414 #[serde(skip_serializing_if="Option::is_none")]
415 pub size
: Option
<u64>,
426 #[derive(Clone, Serialize, Deserialize)]
427 #[serde(rename_all="kebab-case")]
428 /// Garbage collection status.
429 pub struct GarbageCollectionStatus
{
430 pub upid
: Option
<String
>,
431 /// Number of processed index files.
432 pub index_file_count
: usize,
433 /// Sum of bytes referred by index files.
434 pub index_data_bytes
: u64,
435 /// Bytes used on disk.
437 /// Chunks used on disk.
438 pub disk_chunks
: usize,
439 /// Sum of removed bytes.
440 pub removed_bytes
: u64,
441 /// Number of removed chunks.
442 pub removed_chunks
: usize,
443 /// Sum of pending bytes (pending removal - kept for safety).
444 pub pending_bytes
: u64,
445 /// Number of pending chunks (pending removal - kept for safety).
446 pub pending_chunks
: usize,
449 impl Default
for GarbageCollectionStatus
{
450 fn default() -> Self {
451 GarbageCollectionStatus
{
467 #[derive(Serialize, Deserialize)]
468 /// Storage space usage information.
469 pub struct StorageStatus
{
470 /// Total space (bytes).
472 /// Used space (bytes).
474 /// Available space (bytes).
480 "upid": { schema: UPID_SCHEMA }
,
483 #[derive(Serialize, Deserialize)]
485 pub struct TaskListItem
{
487 /// The node name where the task is running on.
491 /// The task start time (Epoch)
493 /// The task start time (Epoch)
495 /// Worker type (arbitrary ASCII string)
496 pub worker_type
: String
,
497 /// Worker ID (arbitrary ASCII string)
498 pub worker_id
: Option
<String
>,
499 /// The user who started the task
501 /// The task end time (Epoch)
502 #[serde(skip_serializing_if="Option::is_none")]
503 pub endtime
: Option
<i64>,
505 #[serde(skip_serializing_if="Option::is_none")]
506 pub status
: Option
<String
>,
510 #[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
511 #[serde(rename_all = "lowercase")]
512 /// Interface configuration method
513 pub enum NetworkConfigMethod
{
514 /// Configuration is done manually using other tools
516 /// Define interfaces with statically allocated addresses.
518 /// Obtain an address via DHCP
520 /// Define the loopback interface.
525 #[derive(Debug, Copy, Clone, PartialEq, Serialize, Deserialize)]
526 #[serde(rename_all = "lowercase")]
527 /// Network interface type
528 pub enum NetworkInterfaceType
{
531 /// Physical Ethernet device
533 /// Name looks like a physical ethernet device, but device is not found
539 /// Linux VLAN (eth.10)
541 /// Interface Alias (eth:1)
543 /// Unknown interface type
547 pub const NETWORK_INTERFACE_NAME_SCHEMA
: Schema
= StringSchema
::new("Network interface name.")
548 .format(&NETWORK_INTERFACE_FORMAT
)
550 .max_length(libc
::IFNAMSIZ
-1)
553 pub const NETWORK_INTERFACE_LIST_SCHEMA
: Schema
= ArraySchema
::new(
554 "Network interface list.", &NETWORK_INTERFACE_NAME_SCHEMA
)
560 schema
: NETWORK_INTERFACE_NAME_SCHEMA
,
563 type: NetworkInterfaceType
,
566 type: NetworkConfigMethod
,
570 type: NetworkConfigMethod
,
574 description
: "Option list (inet)",
577 description
: "Optional attribute line.",
582 description
: "Option list (inet6)",
585 description
: "Optional attribute line.",
590 description
: "Comments (inet, may span multiple lines)",
595 description
: "Comments (inet6, may span multiple lines)",
600 schema
: NETWORK_INTERFACE_LIST_SCHEMA
,
604 schema
: NETWORK_INTERFACE_LIST_SCHEMA
,
609 #[derive(Debug, Serialize, Deserialize)]
610 /// Network Interface configuration
611 pub struct Interface
{
612 /// Autostart interface
614 /// Interface is active (UP)
619 pub interface_type
: NetworkInterfaceType
,
620 #[serde(skip_serializing_if="Option::is_none")]
621 pub method_v4
: Option
<NetworkConfigMethod
>,
622 #[serde(skip_serializing_if="Option::is_none")]
623 pub method_v6
: Option
<NetworkConfigMethod
>,
624 #[serde(skip_serializing_if="Option::is_none")]
625 /// IPv4 address with netmask
626 pub cidr_v4
: Option
<String
>,
627 #[serde(skip_serializing_if="Option::is_none")]
629 pub gateway_v4
: Option
<String
>,
630 #[serde(skip_serializing_if="Option::is_none")]
631 /// IPv6 address with netmask
632 pub cidr_v6
: Option
<String
>,
633 #[serde(skip_serializing_if="Option::is_none")]
635 pub gateway_v6
: Option
<String
>,
637 #[serde(skip_serializing_if="Vec::is_empty")]
638 pub options_v4
: Vec
<String
>,
639 #[serde(skip_serializing_if="Vec::is_empty")]
640 pub options_v6
: Vec
<String
>,
642 #[serde(skip_serializing_if="Option::is_none")]
643 pub comments_v4
: Option
<String
>,
644 #[serde(skip_serializing_if="Option::is_none")]
645 pub comments_v6
: Option
<String
>,
647 #[serde(skip_serializing_if="Option::is_none")]
648 /// Maximum Transmission Unit
649 pub mtu
: Option
<u64>,
651 #[serde(skip_serializing_if="Option::is_none")]
652 pub bridge_ports
: Option
<Vec
<String
>>,
654 #[serde(skip_serializing_if="Option::is_none")]
655 pub bond_slaves
: Option
<Vec
<String
>>,
661 fn test_cert_fingerprint_schema() -> Result
<(), anyhow
::Error
> {
663 let schema
= CERT_FINGERPRINT_SHA256_SCHEMA
;
665 let invalid_fingerprints
= [
666 "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",
667 "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",
668 "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",
669 "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",
670 "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",
671 "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",
674 for fingerprint
in invalid_fingerprints
.iter() {
675 if let Ok(_
) = parse_simple_value(fingerprint
, &schema
) {
676 bail
!("test fingerprint '{}' failed - got Ok() while expection an error.", fingerprint
);
680 let valid_fingerprints
= [
681 "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",
682 "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",
685 for fingerprint
in valid_fingerprints
.iter() {
686 let v
= match parse_simple_value(fingerprint
, &schema
) {
689 bail
!("unable to parse fingerprint '{}' - {}", fingerprint
, err
);
693 if v
!= serde_json
::json
!(fingerprint
) {
694 bail
!("unable to parse fingerprint '{}' - got wrong value {:?}", fingerprint
, v
);
702 fn test_proxmox_user_id_schema() -> Result
<(), anyhow
::Error
> {
704 let schema
= PROXMOX_USER_ID_SCHEMA
;
706 let invalid_user_ids
= [
711 "xx x@test", // contains space
712 "xx\nx@test", // contains control character
713 "x:xx@test", // contains collon
714 "xx/x@test", // contains slash
715 "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx@test", // too long
718 for name
in invalid_user_ids
.iter() {
719 if let Ok(_
) = parse_simple_value(name
, &schema
) {
720 bail
!("test userid '{}' failed - got Ok() while expection an error.", name
);
724 let valid_user_ids
= [
728 "xxx@_T_E_S_T-it.com",
729 "x_x-x.x@test-it.com",
732 for name
in valid_user_ids
.iter() {
733 let v
= match parse_simple_value(name
, &schema
) {
736 bail
!("unable to parse userid '{}' - {}", name
, err
);
740 if v
!= serde_json
::json
!(name
) {
741 bail
!("unable to parse userid '{}' - got wrong value {:?}", name
, v
);