2048 lines
122 KiB
Rust
2048 lines
122 KiB
Rust
// Code generated by tools/generate.py; DO NOT EDIT.
|
|
#![allow(non_snake_case)]
|
|
pub const SCHEMA_SHA256: &str = "762d009c3d25d80c3850d975e45f7a6b3fd8adf5c93c8fa7dd11dfa993f8bbb1";
|
|
pub const CURRENT_WIRE_VERSION: &str = "2";
|
|
pub const N_MINUS_1_WIRE_VERSION: &str = "1";
|
|
pub const N_MINUS_2_WIRE_VERSION: &str = "0";
|
|
pub type JsonObject = std::collections::BTreeMap<String, String>;
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ValidationError { pub field: &'static str, pub code: &'static str }
|
|
impl ValidationError { pub const fn new(field: &'static str, code: &'static str) -> Self { Self { field, code } } }
|
|
|
|
fn base64url_value(value: u8) -> Option<u8> {
|
|
match value {
|
|
b'A'..=b'Z' => Some(value - b'A'),
|
|
b'a'..=b'z' => Some(value - b'a' + 26),
|
|
b'0'..=b'9' => Some(value - b'0' + 52),
|
|
b'-' => Some(62),
|
|
b'_' => Some(63),
|
|
_ => None,
|
|
}
|
|
}
|
|
fn valid_base64_url(value: &str) -> bool {
|
|
let bytes = value.as_bytes();
|
|
if bytes.is_empty() || bytes.iter().any(|byte| base64url_value(*byte).is_none()) { return false; }
|
|
match bytes.len() % 4 {
|
|
0 => true,
|
|
2 => base64url_value(*bytes.last().unwrap()).unwrap() & 0x0f == 0,
|
|
3 => base64url_value(*bytes.last().unwrap()).unwrap() & 0x03 == 0,
|
|
_ => false,
|
|
}
|
|
}
|
|
fn valid_rfc3339_utc(value: &str) -> bool {
|
|
let bytes = value.as_bytes();
|
|
if bytes.len() < 20 || bytes.len() > 30 || bytes[4] != b'-' || bytes[7] != b'-' || bytes[10] != b'T' || bytes[13] != b':' || bytes[16] != b':' || *bytes.last().unwrap() != b'Z' { return false; }
|
|
let digits = |start: usize, end: usize| -> Option<u32> { bytes.get(start..end)?.iter().try_fold(0u32, |value, byte| if byte.is_ascii_digit() { Some(value * 10 + u32::from(*byte - b'0')) } else { None }) };
|
|
let (year, month, day, hour, minute, second) = match (digits(0, 4), digits(5, 7), digits(8, 10), digits(11, 13), digits(14, 16), digits(17, 19)) { (Some(year), Some(month), Some(day), Some(hour), Some(minute), Some(second)) => (year, month, day, hour, minute, second), _ => return false };
|
|
if hour > 23 || minute > 59 || second > 59 { return false; }
|
|
let leap = year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
|
|
let days = match month { 1 | 3 | 5 | 7 | 8 | 10 | 12 => 31, 4 | 6 | 9 | 11 => 30, 2 if leap => 29, 2 => 28, _ => return false };
|
|
if day == 0 || day > days { return false; }
|
|
if bytes.len() == 20 { return true; }
|
|
let fraction = &bytes[20..bytes.len() - 1];
|
|
bytes[19] == b'.' && !fraction.is_empty() && fraction.len() <= 9 && fraction.iter().all(u8::is_ascii_digit) && *fraction.last().unwrap() != b'0'
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct AllocationPolicy {
|
|
minimumKbps: i64,
|
|
targetKbps: i64,
|
|
maximumKbps: i64,
|
|
tier: String,
|
|
audience: String,
|
|
protocol: String,
|
|
protocolVersion: i64,
|
|
grantTtlSeconds: i64,
|
|
reservationLeaseSeconds: i64,
|
|
}
|
|
|
|
impl AllocationPolicy {
|
|
pub fn new(minimumKbps: i64, targetKbps: i64, maximumKbps: i64, tier: String, audience: String, protocol: String, protocolVersion: i64, grantTtlSeconds: i64, reservationLeaseSeconds: i64) -> Result<Self, ValidationError> {
|
|
let value = Self { minimumKbps, targetKbps, maximumKbps, tier, audience, protocol, protocolVersion, grantTtlSeconds, reservationLeaseSeconds };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.minimumKbps < 1 { return Err(ValidationError::new("minimum_kbps", "minimum")); }
|
|
if self.minimumKbps > 100000000 { return Err(ValidationError::new("minimum_kbps", "maximum")); }
|
|
if self.targetKbps < 1 { return Err(ValidationError::new("target_kbps", "minimum")); }
|
|
if self.targetKbps > 100000000 { return Err(ValidationError::new("target_kbps", "maximum")); }
|
|
if self.maximumKbps < 1 { return Err(ValidationError::new("maximum_kbps", "minimum")); }
|
|
if self.maximumKbps > 100000000 { return Err(ValidationError::new("maximum_kbps", "maximum")); }
|
|
if self.tier != "standard" && self.tier != "priority" && self.tier != "premium" { return Err(ValidationError::new("tier", "invalid_value")); }
|
|
if self.audience.is_empty() { return Err(ValidationError::new("audience", "required")); }
|
|
if !self.audience.is_empty() && self.audience.len() < 1 { return Err(ValidationError::new("audience", "min_length")); }
|
|
if self.audience.len() > 256 { return Err(ValidationError::new("audience", "max_length")); }
|
|
if self.protocol.is_empty() { return Err(ValidationError::new("protocol", "required")); }
|
|
if !self.protocol.is_empty() && self.protocol.len() < 1 { return Err(ValidationError::new("protocol", "min_length")); }
|
|
if self.protocol.len() > 64 { return Err(ValidationError::new("protocol", "max_length")); }
|
|
if self.protocolVersion < 1 { return Err(ValidationError::new("protocol_version", "minimum")); }
|
|
if self.protocolVersion > 100 { return Err(ValidationError::new("protocol_version", "maximum")); }
|
|
if self.grantTtlSeconds < 5 { return Err(ValidationError::new("grant_ttl_seconds", "minimum")); }
|
|
if self.grantTtlSeconds > 300 { return Err(ValidationError::new("grant_ttl_seconds", "maximum")); }
|
|
if self.reservationLeaseSeconds < 5 { return Err(ValidationError::new("reservation_lease_seconds", "minimum")); }
|
|
if self.reservationLeaseSeconds > 3600 { return Err(ValidationError::new("reservation_lease_seconds", "maximum")); }
|
|
if self.minimumKbps > self.targetKbps || self.targetKbps > self.maximumKbps { return Err(ValidationError::new("bounds", "invalid_order")); }
|
|
Ok(())
|
|
}
|
|
pub fn minimumKbps(&self) -> &i64 { &self.minimumKbps }
|
|
pub fn targetKbps(&self) -> &i64 { &self.targetKbps }
|
|
pub fn maximumKbps(&self) -> &i64 { &self.maximumKbps }
|
|
pub fn tier(&self) -> &String { &self.tier }
|
|
pub fn audience(&self) -> &String { &self.audience }
|
|
pub fn protocol(&self) -> &String { &self.protocol }
|
|
pub fn protocolVersion(&self) -> &i64 { &self.protocolVersion }
|
|
pub fn grantTtlSeconds(&self) -> &i64 { &self.grantTtlSeconds }
|
|
pub fn reservationLeaseSeconds(&self) -> &i64 { &self.reservationLeaseSeconds }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct AssignedDesktop {
|
|
assignmentId: String,
|
|
poolId: String,
|
|
name: String,
|
|
availability: String,
|
|
}
|
|
|
|
impl AssignedDesktop {
|
|
pub fn new(assignmentId: String, poolId: String, name: String, availability: String) -> Result<Self, ValidationError> {
|
|
let value = Self { assignmentId, poolId, name, availability };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.assignmentId.is_empty() { return Err(ValidationError::new("assignment_id", "required")); }
|
|
if !self.assignmentId.is_empty() && self.assignmentId.len() < 1 { return Err(ValidationError::new("assignment_id", "min_length")); }
|
|
if self.assignmentId.len() > 128 { return Err(ValidationError::new("assignment_id", "max_length")); }
|
|
if self.poolId.is_empty() { return Err(ValidationError::new("pool_id", "required")); }
|
|
if !self.poolId.is_empty() && self.poolId.len() < 1 { return Err(ValidationError::new("pool_id", "min_length")); }
|
|
if self.poolId.len() > 128 { return Err(ValidationError::new("pool_id", "max_length")); }
|
|
if self.name.is_empty() { return Err(ValidationError::new("name", "required")); }
|
|
if !self.name.is_empty() && self.name.len() < 1 { return Err(ValidationError::new("name", "min_length")); }
|
|
if self.name.len() > 256 { return Err(ValidationError::new("name", "max_length")); }
|
|
if self.availability.is_empty() { return Err(ValidationError::new("availability", "required")); }
|
|
if !self.availability.is_empty() && self.availability.len() < 1 { return Err(ValidationError::new("availability", "min_length")); }
|
|
if self.availability.len() > 64 { return Err(ValidationError::new("availability", "max_length")); }
|
|
Ok(())
|
|
}
|
|
pub fn assignmentId(&self) -> &String { &self.assignmentId }
|
|
pub fn poolId(&self) -> &String { &self.poolId }
|
|
pub fn name(&self) -> &String { &self.name }
|
|
pub fn availability(&self) -> &String { &self.availability }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct BrokerSession {
|
|
id: String,
|
|
principalId: String,
|
|
poolId: String,
|
|
assignmentId: Option<String>,
|
|
state: String,
|
|
policySnapshot: AllocationPolicy,
|
|
reconnectDeadline: Option<String>,
|
|
outcome: Option<String>,
|
|
failureCode: Option<String>,
|
|
cleanupState: String,
|
|
idempotencyKey: String,
|
|
correlationId: String,
|
|
requestedAt: String,
|
|
endedAt: Option<String>,
|
|
version: i64,
|
|
requestedDisplayMode: Option<DisplayMode>,
|
|
effectiveDisplayMode: Option<DisplayMode>,
|
|
}
|
|
|
|
impl BrokerSession {
|
|
pub fn new(id: String, principalId: String, poolId: String, assignmentId: Option<String>, state: String, policySnapshot: AllocationPolicy, reconnectDeadline: Option<String>, outcome: Option<String>, failureCode: Option<String>, cleanupState: String, idempotencyKey: String, correlationId: String, requestedAt: String, endedAt: Option<String>, version: i64, requestedDisplayMode: Option<DisplayMode>, effectiveDisplayMode: Option<DisplayMode>) -> Result<Self, ValidationError> {
|
|
let value = Self { id, principalId, poolId, assignmentId, state, policySnapshot, reconnectDeadline, outcome, failureCode, cleanupState, idempotencyKey, correlationId, requestedAt, endedAt, version, requestedDisplayMode, effectiveDisplayMode };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.id.is_empty() { return Err(ValidationError::new("id", "required")); }
|
|
if !self.id.is_empty() && self.id.len() < 1 { return Err(ValidationError::new("id", "min_length")); }
|
|
if self.id.len() > 128 { return Err(ValidationError::new("id", "max_length")); }
|
|
if self.principalId.is_empty() { return Err(ValidationError::new("principal_id", "required")); }
|
|
if !self.principalId.is_empty() && self.principalId.len() < 1 { return Err(ValidationError::new("principal_id", "min_length")); }
|
|
if self.principalId.len() > 128 { return Err(ValidationError::new("principal_id", "max_length")); }
|
|
if self.poolId.is_empty() { return Err(ValidationError::new("pool_id", "required")); }
|
|
if !self.poolId.is_empty() && self.poolId.len() < 1 { return Err(ValidationError::new("pool_id", "min_length")); }
|
|
if self.poolId.len() > 128 { return Err(ValidationError::new("pool_id", "max_length")); }
|
|
if let Some(value) = &self.assignmentId {
|
|
if value.len() > 128 { return Err(ValidationError::new("assignment_id", "max_length")); }
|
|
}
|
|
if self.state.is_empty() { return Err(ValidationError::new("state", "required")); }
|
|
if !self.state.is_empty() && self.state.len() < 1 { return Err(ValidationError::new("state", "min_length")); }
|
|
if self.state.len() > 64 { return Err(ValidationError::new("state", "max_length")); }
|
|
self.policySnapshot.validate().map_err(|_| ValidationError::new("policy_snapshot", "invalid_object"))?;
|
|
if let Some(value) = &self.reconnectDeadline {
|
|
if value.len() > 64 { return Err(ValidationError::new("reconnect_deadline", "max_length")); }
|
|
if !valid_rfc3339_utc(value.as_str()) { return Err(ValidationError::new("reconnect_deadline", "invalid_time")); }
|
|
}
|
|
if let Some(value) = &self.outcome {
|
|
if value.len() > 64 { return Err(ValidationError::new("outcome", "max_length")); }
|
|
}
|
|
if let Some(value) = &self.failureCode {
|
|
if value.len() > 128 { return Err(ValidationError::new("failure_code", "max_length")); }
|
|
}
|
|
if self.cleanupState.is_empty() { return Err(ValidationError::new("cleanup_state", "required")); }
|
|
if !self.cleanupState.is_empty() && self.cleanupState.len() < 1 { return Err(ValidationError::new("cleanup_state", "min_length")); }
|
|
if self.cleanupState.len() > 64 { return Err(ValidationError::new("cleanup_state", "max_length")); }
|
|
if self.idempotencyKey.is_empty() { return Err(ValidationError::new("idempotency_key", "required")); }
|
|
if !self.idempotencyKey.is_empty() && self.idempotencyKey.len() < 1 { return Err(ValidationError::new("idempotency_key", "min_length")); }
|
|
if self.idempotencyKey.len() > 256 { return Err(ValidationError::new("idempotency_key", "max_length")); }
|
|
if self.correlationId.is_empty() { return Err(ValidationError::new("correlation_id", "required")); }
|
|
if !self.correlationId.is_empty() && self.correlationId.len() < 1 { return Err(ValidationError::new("correlation_id", "min_length")); }
|
|
if self.correlationId.len() > 128 { return Err(ValidationError::new("correlation_id", "max_length")); }
|
|
if self.requestedAt.len() > 64 { return Err(ValidationError::new("requested_at", "max_length")); }
|
|
if !valid_rfc3339_utc(self.requestedAt.as_str()) { return Err(ValidationError::new("requested_at", "invalid_time")); }
|
|
if let Some(value) = &self.endedAt {
|
|
if value.len() > 64 { return Err(ValidationError::new("ended_at", "max_length")); }
|
|
if !valid_rfc3339_utc(value.as_str()) { return Err(ValidationError::new("ended_at", "invalid_time")); }
|
|
}
|
|
if self.version < 1 { return Err(ValidationError::new("version", "minimum")); }
|
|
if let Some(value) = &self.requestedDisplayMode {
|
|
value.validate().map_err(|_| ValidationError::new("requested_display_mode", "invalid_object"))?;
|
|
}
|
|
if let Some(value) = &self.effectiveDisplayMode {
|
|
value.validate().map_err(|_| ValidationError::new("effective_display_mode", "invalid_object"))?;
|
|
}
|
|
Ok(())
|
|
}
|
|
pub fn id(&self) -> &String { &self.id }
|
|
pub fn principalId(&self) -> &String { &self.principalId }
|
|
pub fn poolId(&self) -> &String { &self.poolId }
|
|
pub fn assignmentId(&self) -> &Option<String> { &self.assignmentId }
|
|
pub fn state(&self) -> &String { &self.state }
|
|
pub fn policySnapshot(&self) -> &AllocationPolicy { &self.policySnapshot }
|
|
pub fn reconnectDeadline(&self) -> &Option<String> { &self.reconnectDeadline }
|
|
pub fn outcome(&self) -> &Option<String> { &self.outcome }
|
|
pub fn failureCode(&self) -> &Option<String> { &self.failureCode }
|
|
pub fn cleanupState(&self) -> &String { &self.cleanupState }
|
|
pub fn idempotencyKey(&self) -> &String { &self.idempotencyKey }
|
|
pub fn correlationId(&self) -> &String { &self.correlationId }
|
|
pub fn requestedAt(&self) -> &String { &self.requestedAt }
|
|
pub fn endedAt(&self) -> &Option<String> { &self.endedAt }
|
|
pub fn version(&self) -> &i64 { &self.version }
|
|
pub fn requestedDisplayMode(&self) -> &Option<DisplayMode> { &self.requestedDisplayMode }
|
|
pub fn effectiveDisplayMode(&self) -> &Option<DisplayMode> { &self.effectiveDisplayMode }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct BrowserAuthenticatedSession {
|
|
username: String,
|
|
provider: String,
|
|
roles: Vec<String>,
|
|
role: String,
|
|
}
|
|
|
|
impl BrowserAuthenticatedSession {
|
|
pub fn new(username: String, provider: String, roles: Vec<String>, role: String) -> Result<Self, ValidationError> {
|
|
let value = Self { username, provider, roles, role };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.username.is_empty() { return Err(ValidationError::new("username", "required")); }
|
|
if !self.username.is_empty() && self.username.len() < 1 { return Err(ValidationError::new("username", "min_length")); }
|
|
if self.username.len() > 256 { return Err(ValidationError::new("username", "max_length")); }
|
|
if self.provider.is_empty() { return Err(ValidationError::new("provider", "required")); }
|
|
if !self.provider.is_empty() && self.provider.len() < 1 { return Err(ValidationError::new("provider", "min_length")); }
|
|
if self.provider.len() > 64 { return Err(ValidationError::new("provider", "max_length")); }
|
|
if self.roles.len() > 16 { return Err(ValidationError::new("roles", "max_items")); }
|
|
for item in self.roles.iter() { if item.as_bytes().len() < 1 { return Err(ValidationError::new("roles", "min_item_length")); } }
|
|
for item in self.roles.iter() { if item.as_bytes().len() > 64 { return Err(ValidationError::new("roles", "max_item_length")); } }
|
|
for item in self.roles.iter() { if item.as_bytes().len() > 64 { return Err(ValidationError::new("roles", "max_item_bytes")); } }
|
|
if self.role != "user" && self.role != "admin" { return Err(ValidationError::new("role", "invalid_value")); }
|
|
Ok(())
|
|
}
|
|
pub fn username(&self) -> &String { &self.username }
|
|
pub fn provider(&self) -> &String { &self.provider }
|
|
pub fn roles(&self) -> &Vec<String> { &self.roles }
|
|
pub fn role(&self) -> &String { &self.role }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct CapabilityProfile {
|
|
transport: String,
|
|
framing: String,
|
|
media: String,
|
|
audio: String,
|
|
sourceRateControl: String,
|
|
clientDecode: Vec<String>,
|
|
}
|
|
|
|
impl CapabilityProfile {
|
|
pub fn new(transport: String, framing: String, media: String, audio: String, sourceRateControl: String, clientDecode: Vec<String>) -> Result<Self, ValidationError> {
|
|
let value = Self { transport, framing, media, audio, sourceRateControl, clientDecode };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.transport.is_empty() { return Err(ValidationError::new("transport", "required")); }
|
|
if !self.transport.is_empty() && self.transport.len() < 1 { return Err(ValidationError::new("transport", "min_length")); }
|
|
if self.transport.len() > 64 { return Err(ValidationError::new("transport", "max_length")); }
|
|
if self.framing != "datagram-v1" && self.framing != "datagram-v2" { return Err(ValidationError::new("framing", "invalid_value")); }
|
|
if self.media.is_empty() { return Err(ValidationError::new("media", "required")); }
|
|
if !self.media.is_empty() && self.media.len() < 1 { return Err(ValidationError::new("media", "min_length")); }
|
|
if self.media.len() > 64 { return Err(ValidationError::new("media", "max_length")); }
|
|
if self.audio.is_empty() { return Err(ValidationError::new("audio", "required")); }
|
|
if !self.audio.is_empty() && self.audio.len() < 1 { return Err(ValidationError::new("audio", "min_length")); }
|
|
if self.audio.len() > 64 { return Err(ValidationError::new("audio", "max_length")); }
|
|
if self.sourceRateControl.is_empty() { return Err(ValidationError::new("source_rate_control", "required")); }
|
|
if !self.sourceRateControl.is_empty() && self.sourceRateControl.len() < 1 { return Err(ValidationError::new("source_rate_control", "min_length")); }
|
|
if self.sourceRateControl.len() > 64 { return Err(ValidationError::new("source_rate_control", "max_length")); }
|
|
if self.clientDecode.len() < 1 { return Err(ValidationError::new("client_decode", "min_items")); }
|
|
if self.clientDecode.len() > 2 { return Err(ValidationError::new("client_decode", "max_items")); }
|
|
for item in self.clientDecode.iter() { if item != "h264-opus" && item != "hevc-opus" { return Err(ValidationError::new("client_decode", "invalid_item")); } }
|
|
for (index, item) in self.clientDecode.iter().enumerate() { if self.clientDecode[..index].contains(item) { return Err(ValidationError::new("client_decode", "duplicate_item")); } }
|
|
Ok(())
|
|
}
|
|
pub fn transport(&self) -> &String { &self.transport }
|
|
pub fn framing(&self) -> &String { &self.framing }
|
|
pub fn media(&self) -> &String { &self.media }
|
|
pub fn audio(&self) -> &String { &self.audio }
|
|
pub fn sourceRateControl(&self) -> &String { &self.sourceRateControl }
|
|
pub fn clientDecode(&self) -> &Vec<String> { &self.clientDecode }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ChannelFrame {
|
|
version: String,
|
|
flowId: String,
|
|
sequence: i64,
|
|
flags: i64,
|
|
fragmentIndex: i64,
|
|
fragmentCount: i64,
|
|
timestampMs: i64,
|
|
payload: String,
|
|
}
|
|
|
|
impl ChannelFrame {
|
|
pub fn new(version: String, flowId: String, sequence: i64, flags: i64, fragmentIndex: i64, fragmentCount: i64, timestampMs: i64, payload: String) -> Result<Self, ValidationError> {
|
|
let value = Self { version, flowId, sequence, flags, fragmentIndex, fragmentCount, timestampMs, payload };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.version != "1" { return Err(ValidationError::new("version", "invalid_value")); }
|
|
if self.flowId.is_empty() { return Err(ValidationError::new("flow_id", "required")); }
|
|
if !self.flowId.is_empty() && self.flowId.len() < 1 { return Err(ValidationError::new("flow_id", "min_length")); }
|
|
if self.flowId.len() > 64 { return Err(ValidationError::new("flow_id", "max_length")); }
|
|
if self.sequence < 0 { return Err(ValidationError::new("sequence", "minimum")); }
|
|
if self.flags < 0 { return Err(ValidationError::new("flags", "minimum")); }
|
|
if self.flags > 255 { return Err(ValidationError::new("flags", "maximum")); }
|
|
if self.fragmentIndex < 0 { return Err(ValidationError::new("fragment_index", "minimum")); }
|
|
if self.fragmentIndex > 15 { return Err(ValidationError::new("fragment_index", "maximum")); }
|
|
if self.fragmentCount < 1 { return Err(ValidationError::new("fragment_count", "minimum")); }
|
|
if self.fragmentCount > 16 { return Err(ValidationError::new("fragment_count", "maximum")); }
|
|
if self.timestampMs < 0 { return Err(ValidationError::new("timestamp_ms", "minimum")); }
|
|
if self.payload.len() > 87384 { return Err(ValidationError::new("payload", "max_length")); }
|
|
if self.payload.as_bytes().len() > 65536 { return Err(ValidationError::new("payload", "max_bytes")); }
|
|
if self.fragmentIndex >= self.fragmentCount { return Err(ValidationError::new("fragment_index", "invalid_order")); }
|
|
Ok(())
|
|
}
|
|
pub fn version(&self) -> &String { &self.version }
|
|
pub fn flowId(&self) -> &String { &self.flowId }
|
|
pub fn sequence(&self) -> &i64 { &self.sequence }
|
|
pub fn flags(&self) -> &i64 { &self.flags }
|
|
pub fn fragmentIndex(&self) -> &i64 { &self.fragmentIndex }
|
|
pub fn fragmentCount(&self) -> &i64 { &self.fragmentCount }
|
|
pub fn timestampMs(&self) -> &i64 { &self.timestampMs }
|
|
pub fn payload(&self) -> &String { &self.payload }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ClientSessionAuthority {
|
|
version: String,
|
|
sessionId: String,
|
|
gatewayId: String,
|
|
audience: String,
|
|
reconnectSequence: i64,
|
|
expiresAt: String,
|
|
capabilities: CapabilityProfile,
|
|
}
|
|
|
|
impl ClientSessionAuthority {
|
|
pub fn new(version: String, sessionId: String, gatewayId: String, audience: String, reconnectSequence: i64, expiresAt: String, capabilities: CapabilityProfile) -> Result<Self, ValidationError> {
|
|
let value = Self { version, sessionId, gatewayId, audience, reconnectSequence, expiresAt, capabilities };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.version != "1" { return Err(ValidationError::new("version", "invalid_value")); }
|
|
if self.sessionId.is_empty() { return Err(ValidationError::new("session_id", "required")); }
|
|
if !self.sessionId.is_empty() && self.sessionId.len() < 1 { return Err(ValidationError::new("session_id", "min_length")); }
|
|
if self.sessionId.len() > 128 { return Err(ValidationError::new("session_id", "max_length")); }
|
|
if self.gatewayId.is_empty() { return Err(ValidationError::new("gateway_id", "required")); }
|
|
if !self.gatewayId.is_empty() && self.gatewayId.len() < 1 { return Err(ValidationError::new("gateway_id", "min_length")); }
|
|
if self.gatewayId.len() > 128 { return Err(ValidationError::new("gateway_id", "max_length")); }
|
|
if self.audience.is_empty() { return Err(ValidationError::new("audience", "required")); }
|
|
if !self.audience.is_empty() && self.audience.len() < 1 { return Err(ValidationError::new("audience", "min_length")); }
|
|
if self.audience.len() > 256 { return Err(ValidationError::new("audience", "max_length")); }
|
|
if self.reconnectSequence < 0 { return Err(ValidationError::new("reconnect_sequence", "minimum")); }
|
|
if self.expiresAt.len() > 64 { return Err(ValidationError::new("expires_at", "max_length")); }
|
|
if !valid_rfc3339_utc(self.expiresAt.as_str()) { return Err(ValidationError::new("expires_at", "invalid_time")); }
|
|
self.capabilities.validate().map_err(|_| ValidationError::new("capabilities", "invalid_object"))?;
|
|
Ok(())
|
|
}
|
|
pub fn version(&self) -> &String { &self.version }
|
|
pub fn sessionId(&self) -> &String { &self.sessionId }
|
|
pub fn gatewayId(&self) -> &String { &self.gatewayId }
|
|
pub fn audience(&self) -> &String { &self.audience }
|
|
pub fn reconnectSequence(&self) -> &i64 { &self.reconnectSequence }
|
|
pub fn expiresAt(&self) -> &String { &self.expiresAt }
|
|
pub fn capabilities(&self) -> &CapabilityProfile { &self.capabilities }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ClipboardPolicy {
|
|
clientToProviderEnabled: bool,
|
|
providerToClientEnabled: bool,
|
|
maxTextBytes: i64,
|
|
maxUpdatesPerMinute: i64,
|
|
}
|
|
|
|
impl ClipboardPolicy {
|
|
pub fn new(clientToProviderEnabled: bool, providerToClientEnabled: bool, maxTextBytes: i64, maxUpdatesPerMinute: i64) -> Result<Self, ValidationError> {
|
|
let value = Self { clientToProviderEnabled, providerToClientEnabled, maxTextBytes, maxUpdatesPerMinute };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.maxTextBytes < 1 { return Err(ValidationError::new("max_text_bytes", "minimum")); }
|
|
if self.maxTextBytes > 65536 { return Err(ValidationError::new("max_text_bytes", "maximum")); }
|
|
if self.maxUpdatesPerMinute < 1 { return Err(ValidationError::new("max_updates_per_minute", "minimum")); }
|
|
if self.maxUpdatesPerMinute > 120 { return Err(ValidationError::new("max_updates_per_minute", "maximum")); }
|
|
Ok(())
|
|
}
|
|
pub fn clientToProviderEnabled(&self) -> &bool { &self.clientToProviderEnabled }
|
|
pub fn providerToClientEnabled(&self) -> &bool { &self.providerToClientEnabled }
|
|
pub fn maxTextBytes(&self) -> &i64 { &self.maxTextBytes }
|
|
pub fn maxUpdatesPerMinute(&self) -> &i64 { &self.maxUpdatesPerMinute }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ClipboardText {
|
|
text: String,
|
|
encoding: String,
|
|
}
|
|
|
|
impl ClipboardText {
|
|
pub fn new(text: String, encoding: String) -> Result<Self, ValidationError> {
|
|
let value = Self { text, encoding };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.text.len() > 65536 { return Err(ValidationError::new("text", "max_length")); }
|
|
if self.encoding != "utf-8" { return Err(ValidationError::new("encoding", "invalid_value")); }
|
|
Ok(())
|
|
}
|
|
pub fn text(&self) -> &String { &self.text }
|
|
pub fn encoding(&self) -> &String { &self.encoding }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ConnectionManifest {
|
|
version: String,
|
|
purpose: String,
|
|
sessionId: String,
|
|
reconnectSequence: i64,
|
|
gateway: ManifestGateway,
|
|
tunnel: ManifestTunnel,
|
|
profile: ManifestProfile,
|
|
grant: GrantReference,
|
|
correlationId: String,
|
|
}
|
|
|
|
impl ConnectionManifest {
|
|
pub fn new(version: String, purpose: String, sessionId: String, reconnectSequence: i64, gateway: ManifestGateway, tunnel: ManifestTunnel, profile: ManifestProfile, grant: GrantReference, correlationId: String) -> Result<Self, ValidationError> {
|
|
let value = Self { version, purpose, sessionId, reconnectSequence, gateway, tunnel, profile, grant, correlationId };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.version != "1" { return Err(ValidationError::new("version", "invalid_value")); }
|
|
if self.purpose != "launch" && self.purpose != "reconnect" { return Err(ValidationError::new("purpose", "invalid_value")); }
|
|
if self.sessionId.is_empty() { return Err(ValidationError::new("session_id", "required")); }
|
|
if !self.sessionId.is_empty() && self.sessionId.len() < 1 { return Err(ValidationError::new("session_id", "min_length")); }
|
|
if self.sessionId.len() > 128 { return Err(ValidationError::new("session_id", "max_length")); }
|
|
if self.reconnectSequence < 0 { return Err(ValidationError::new("reconnect_sequence", "minimum")); }
|
|
self.gateway.validate().map_err(|_| ValidationError::new("gateway", "invalid_object"))?;
|
|
self.tunnel.validate().map_err(|_| ValidationError::new("tunnel", "invalid_object"))?;
|
|
self.profile.validate().map_err(|_| ValidationError::new("profile", "invalid_object"))?;
|
|
self.grant.validate().map_err(|_| ValidationError::new("grant", "invalid_object"))?;
|
|
if self.correlationId.is_empty() { return Err(ValidationError::new("correlation_id", "required")); }
|
|
if !self.correlationId.is_empty() && self.correlationId.len() < 1 { return Err(ValidationError::new("correlation_id", "min_length")); }
|
|
if self.correlationId.len() > 128 { return Err(ValidationError::new("correlation_id", "max_length")); }
|
|
Ok(())
|
|
}
|
|
pub fn version(&self) -> &String { &self.version }
|
|
pub fn purpose(&self) -> &String { &self.purpose }
|
|
pub fn sessionId(&self) -> &String { &self.sessionId }
|
|
pub fn reconnectSequence(&self) -> &i64 { &self.reconnectSequence }
|
|
pub fn gateway(&self) -> &ManifestGateway { &self.gateway }
|
|
pub fn tunnel(&self) -> &ManifestTunnel { &self.tunnel }
|
|
pub fn profile(&self) -> &ManifestProfile { &self.profile }
|
|
pub fn grant(&self) -> &GrantReference { &self.grant }
|
|
pub fn correlationId(&self) -> &String { &self.correlationId }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct DeviceChallenge {
|
|
deviceId: String,
|
|
serverId: String,
|
|
principalId: String,
|
|
challenge: String,
|
|
expiresAt: String,
|
|
algorithm: String,
|
|
signatureFormat: String,
|
|
}
|
|
|
|
impl DeviceChallenge {
|
|
pub fn new(deviceId: String, serverId: String, principalId: String, challenge: String, expiresAt: String, algorithm: String, signatureFormat: String) -> Result<Self, ValidationError> {
|
|
let value = Self { deviceId, serverId, principalId, challenge, expiresAt, algorithm, signatureFormat };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.deviceId.is_empty() { return Err(ValidationError::new("device_id", "required")); }
|
|
if !self.deviceId.is_empty() && self.deviceId.len() < 1 { return Err(ValidationError::new("device_id", "min_length")); }
|
|
if self.deviceId.len() > 128 { return Err(ValidationError::new("device_id", "max_length")); }
|
|
if self.serverId.is_empty() { return Err(ValidationError::new("server_id", "required")); }
|
|
if !self.serverId.is_empty() && self.serverId.len() < 1 { return Err(ValidationError::new("server_id", "min_length")); }
|
|
if self.serverId.len() > 128 { return Err(ValidationError::new("server_id", "max_length")); }
|
|
if self.principalId.is_empty() { return Err(ValidationError::new("principal_id", "required")); }
|
|
if !self.principalId.is_empty() && self.principalId.len() < 1 { return Err(ValidationError::new("principal_id", "min_length")); }
|
|
if self.principalId.len() > 128 { return Err(ValidationError::new("principal_id", "max_length")); }
|
|
if self.challenge.is_empty() { return Err(ValidationError::new("challenge", "required")); }
|
|
if !self.challenge.is_empty() && self.challenge.len() < 1 { return Err(ValidationError::new("challenge", "min_length")); }
|
|
if self.challenge.len() > 256 { return Err(ValidationError::new("challenge", "max_length")); }
|
|
if self.expiresAt.len() > 64 { return Err(ValidationError::new("expires_at", "max_length")); }
|
|
if !valid_rfc3339_utc(self.expiresAt.as_str()) { return Err(ValidationError::new("expires_at", "invalid_time")); }
|
|
if self.algorithm != "ed25519" { return Err(ValidationError::new("algorithm", "invalid_value")); }
|
|
if self.signatureFormat != "ed25519-domain-separated-v1" { return Err(ValidationError::new("signature_format", "invalid_value")); }
|
|
Ok(())
|
|
}
|
|
pub fn deviceId(&self) -> &String { &self.deviceId }
|
|
pub fn serverId(&self) -> &String { &self.serverId }
|
|
pub fn principalId(&self) -> &String { &self.principalId }
|
|
pub fn challenge(&self) -> &String { &self.challenge }
|
|
pub fn expiresAt(&self) -> &String { &self.expiresAt }
|
|
pub fn algorithm(&self) -> &String { &self.algorithm }
|
|
pub fn signatureFormat(&self) -> &String { &self.signatureFormat }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct DeviceProofRequest {
|
|
challenge: String,
|
|
signature: String,
|
|
}
|
|
|
|
impl DeviceProofRequest {
|
|
pub fn new(challenge: String, signature: String) -> Result<Self, ValidationError> {
|
|
let value = Self { challenge, signature };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.challenge.is_empty() { return Err(ValidationError::new("challenge", "required")); }
|
|
if !self.challenge.is_empty() && self.challenge.len() < 1 { return Err(ValidationError::new("challenge", "min_length")); }
|
|
if self.challenge.len() > 256 { return Err(ValidationError::new("challenge", "max_length")); }
|
|
if self.signature.is_empty() { return Err(ValidationError::new("signature", "required")); }
|
|
if !self.signature.is_empty() && self.signature.len() < 1 { return Err(ValidationError::new("signature", "min_length")); }
|
|
if self.signature.len() > 256 { return Err(ValidationError::new("signature", "max_length")); }
|
|
Ok(())
|
|
}
|
|
pub fn challenge(&self) -> &String { &self.challenge }
|
|
pub fn signature(&self) -> &String { &self.signature }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct DeviceRegistrationRequest {
|
|
name: String,
|
|
platform: String,
|
|
deviceSubject: String,
|
|
algorithm: String,
|
|
publicKey: String,
|
|
}
|
|
|
|
impl DeviceRegistrationRequest {
|
|
pub fn new(name: String, platform: String, deviceSubject: String, algorithm: String, publicKey: String) -> Result<Self, ValidationError> {
|
|
let value = Self { name, platform, deviceSubject, algorithm, publicKey };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.name.is_empty() { return Err(ValidationError::new("name", "required")); }
|
|
if !self.name.is_empty() && self.name.len() < 1 { return Err(ValidationError::new("name", "min_length")); }
|
|
if self.name.len() > 128 { return Err(ValidationError::new("name", "max_length")); }
|
|
if self.platform.is_empty() { return Err(ValidationError::new("platform", "required")); }
|
|
if !self.platform.is_empty() && self.platform.len() < 1 { return Err(ValidationError::new("platform", "min_length")); }
|
|
if self.platform.len() > 64 { return Err(ValidationError::new("platform", "max_length")); }
|
|
if self.deviceSubject.is_empty() { return Err(ValidationError::new("device_subject", "required")); }
|
|
if !self.deviceSubject.is_empty() && self.deviceSubject.len() < 1 { return Err(ValidationError::new("device_subject", "min_length")); }
|
|
if self.deviceSubject.len() > 256 { return Err(ValidationError::new("device_subject", "max_length")); }
|
|
if self.algorithm != "ed25519" { return Err(ValidationError::new("algorithm", "invalid_value")); }
|
|
if self.publicKey.is_empty() { return Err(ValidationError::new("public_key", "required")); }
|
|
if !self.publicKey.is_empty() && self.publicKey.len() < 1 { return Err(ValidationError::new("public_key", "min_length")); }
|
|
if self.publicKey.len() > 256 { return Err(ValidationError::new("public_key", "max_length")); }
|
|
Ok(())
|
|
}
|
|
pub fn name(&self) -> &String { &self.name }
|
|
pub fn platform(&self) -> &String { &self.platform }
|
|
pub fn deviceSubject(&self) -> &String { &self.deviceSubject }
|
|
pub fn algorithm(&self) -> &String { &self.algorithm }
|
|
pub fn publicKey(&self) -> &String { &self.publicKey }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct DisplayMode {
|
|
resolutionWidth: i64,
|
|
resolutionHeight: i64,
|
|
fps: i64,
|
|
}
|
|
|
|
impl DisplayMode {
|
|
pub fn new(resolutionWidth: i64, resolutionHeight: i64, fps: i64) -> Result<Self, ValidationError> {
|
|
let value = Self { resolutionWidth, resolutionHeight, fps };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.resolutionWidth < 320 { return Err(ValidationError::new("resolution_width", "minimum")); }
|
|
if self.resolutionWidth > 16384 { return Err(ValidationError::new("resolution_width", "maximum")); }
|
|
if self.resolutionHeight < 200 { return Err(ValidationError::new("resolution_height", "minimum")); }
|
|
if self.resolutionHeight > 8640 { return Err(ValidationError::new("resolution_height", "maximum")); }
|
|
if self.fps < 1 { return Err(ValidationError::new("fps", "minimum")); }
|
|
if self.fps > 240 { return Err(ValidationError::new("fps", "maximum")); }
|
|
Ok(())
|
|
}
|
|
pub fn resolutionWidth(&self) -> &i64 { &self.resolutionWidth }
|
|
pub fn resolutionHeight(&self) -> &i64 { &self.resolutionHeight }
|
|
pub fn fps(&self) -> &i64 { &self.fps }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct EntitledPool {
|
|
poolId: String,
|
|
name: String,
|
|
assignmentState: String,
|
|
}
|
|
|
|
impl EntitledPool {
|
|
pub fn new(poolId: String, name: String, assignmentState: String) -> Result<Self, ValidationError> {
|
|
let value = Self { poolId, name, assignmentState };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.poolId.is_empty() { return Err(ValidationError::new("pool_id", "required")); }
|
|
if !self.poolId.is_empty() && self.poolId.len() < 1 { return Err(ValidationError::new("pool_id", "min_length")); }
|
|
if self.poolId.len() > 128 { return Err(ValidationError::new("pool_id", "max_length")); }
|
|
if self.name.is_empty() { return Err(ValidationError::new("name", "required")); }
|
|
if !self.name.is_empty() && self.name.len() < 1 { return Err(ValidationError::new("name", "min_length")); }
|
|
if self.name.len() > 256 { return Err(ValidationError::new("name", "max_length")); }
|
|
if self.assignmentState.is_empty() { return Err(ValidationError::new("assignment_state", "required")); }
|
|
if !self.assignmentState.is_empty() && self.assignmentState.len() < 1 { return Err(ValidationError::new("assignment_state", "min_length")); }
|
|
if self.assignmentState.len() > 64 { return Err(ValidationError::new("assignment_state", "max_length")); }
|
|
Ok(())
|
|
}
|
|
pub fn poolId(&self) -> &String { &self.poolId }
|
|
pub fn name(&self) -> &String { &self.name }
|
|
pub fn assignmentState(&self) -> &String { &self.assignmentState }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ErrorEnvelope {
|
|
status: bool,
|
|
error: String,
|
|
code: String,
|
|
message: String,
|
|
resolution: String,
|
|
requestId: String,
|
|
violations: Vec<FieldViolation>,
|
|
}
|
|
|
|
impl ErrorEnvelope {
|
|
pub fn new(status: bool, error: String, code: String, message: String, resolution: String, requestId: String, violations: Vec<FieldViolation>) -> Result<Self, ValidationError> {
|
|
let value = Self { status, error, code, message, resolution, requestId, violations };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.error.is_empty() { return Err(ValidationError::new("error", "required")); }
|
|
if !self.error.is_empty() && self.error.len() < 1 { return Err(ValidationError::new("error", "min_length")); }
|
|
if self.error.len() > 512 { return Err(ValidationError::new("error", "max_length")); }
|
|
if self.code.is_empty() { return Err(ValidationError::new("code", "required")); }
|
|
if !self.code.is_empty() && self.code.len() < 1 { return Err(ValidationError::new("code", "min_length")); }
|
|
if self.code.len() > 128 { return Err(ValidationError::new("code", "max_length")); }
|
|
if self.message.is_empty() { return Err(ValidationError::new("message", "required")); }
|
|
if !self.message.is_empty() && self.message.len() < 1 { return Err(ValidationError::new("message", "min_length")); }
|
|
if self.message.len() > 512 { return Err(ValidationError::new("message", "max_length")); }
|
|
if self.resolution.is_empty() { return Err(ValidationError::new("resolution", "required")); }
|
|
if !self.resolution.is_empty() && self.resolution.len() < 1 { return Err(ValidationError::new("resolution", "min_length")); }
|
|
if self.resolution.len() > 128 { return Err(ValidationError::new("resolution", "max_length")); }
|
|
if self.requestId.is_empty() { return Err(ValidationError::new("request_id", "required")); }
|
|
if !self.requestId.is_empty() && self.requestId.len() < 1 { return Err(ValidationError::new("request_id", "min_length")); }
|
|
if self.requestId.len() > 128 { return Err(ValidationError::new("request_id", "max_length")); }
|
|
if self.violations.len() > 16 { return Err(ValidationError::new("violations", "max_items")); }
|
|
for item in self.violations.iter() { item.validate().map_err(|_| ValidationError::new("violations", "invalid_item"))?; }
|
|
Ok(())
|
|
}
|
|
pub fn status(&self) -> &bool { &self.status }
|
|
pub fn error(&self) -> &String { &self.error }
|
|
pub fn code(&self) -> &String { &self.code }
|
|
pub fn message(&self) -> &String { &self.message }
|
|
pub fn resolution(&self) -> &String { &self.resolution }
|
|
pub fn requestId(&self) -> &String { &self.requestId }
|
|
pub fn violations(&self) -> &Vec<FieldViolation> { &self.violations }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct EventEnvelope {
|
|
eventId: String,
|
|
sequence: i64,
|
|
typeValue: String,
|
|
version: i64,
|
|
resource: ResourceLink,
|
|
occurredAt: String,
|
|
correlationId: String,
|
|
payload: JsonObject,
|
|
}
|
|
|
|
impl EventEnvelope {
|
|
pub fn new(eventId: String, sequence: i64, typeValue: String, version: i64, resource: ResourceLink, occurredAt: String, correlationId: String, payload: JsonObject) -> Result<Self, ValidationError> {
|
|
let value = Self { eventId, sequence, typeValue, version, resource, occurredAt, correlationId, payload };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.eventId.is_empty() { return Err(ValidationError::new("event_id", "required")); }
|
|
if !self.eventId.is_empty() && self.eventId.len() < 1 { return Err(ValidationError::new("event_id", "min_length")); }
|
|
if self.eventId.len() > 128 { return Err(ValidationError::new("event_id", "max_length")); }
|
|
if self.sequence < 1 { return Err(ValidationError::new("sequence", "minimum")); }
|
|
if self.typeValue.is_empty() { return Err(ValidationError::new("type", "required")); }
|
|
if !self.typeValue.is_empty() && self.typeValue.len() < 1 { return Err(ValidationError::new("type", "min_length")); }
|
|
if self.typeValue.len() > 128 { return Err(ValidationError::new("type", "max_length")); }
|
|
if self.version < 1 { return Err(ValidationError::new("version", "minimum")); }
|
|
self.resource.validate().map_err(|_| ValidationError::new("resource", "invalid_object"))?;
|
|
if self.occurredAt.len() > 64 { return Err(ValidationError::new("occurred_at", "max_length")); }
|
|
if !valid_rfc3339_utc(self.occurredAt.as_str()) { return Err(ValidationError::new("occurred_at", "invalid_time")); }
|
|
if self.correlationId.is_empty() { return Err(ValidationError::new("correlation_id", "required")); }
|
|
if !self.correlationId.is_empty() && self.correlationId.len() < 1 { return Err(ValidationError::new("correlation_id", "min_length")); }
|
|
if self.correlationId.len() > 128 { return Err(ValidationError::new("correlation_id", "max_length")); }
|
|
Ok(())
|
|
}
|
|
pub fn eventId(&self) -> &String { &self.eventId }
|
|
pub fn sequence(&self) -> &i64 { &self.sequence }
|
|
pub fn typeValue(&self) -> &String { &self.typeValue }
|
|
pub fn version(&self) -> &i64 { &self.version }
|
|
pub fn resource(&self) -> &ResourceLink { &self.resource }
|
|
pub fn occurredAt(&self) -> &String { &self.occurredAt }
|
|
pub fn correlationId(&self) -> &String { &self.correlationId }
|
|
pub fn payload(&self) -> &JsonObject { &self.payload }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct EventResume {
|
|
cursor: String,
|
|
lastSequence: i64,
|
|
}
|
|
|
|
impl EventResume {
|
|
pub fn new(cursor: String, lastSequence: i64) -> Result<Self, ValidationError> {
|
|
let value = Self { cursor, lastSequence };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.cursor.len() > 512 { return Err(ValidationError::new("cursor", "max_length")); }
|
|
if self.lastSequence < 0 { return Err(ValidationError::new("last_sequence", "minimum")); }
|
|
Ok(())
|
|
}
|
|
pub fn cursor(&self) -> &String { &self.cursor }
|
|
pub fn lastSequence(&self) -> &i64 { &self.lastSequence }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct FieldViolation {
|
|
field: String,
|
|
code: String,
|
|
}
|
|
|
|
impl FieldViolation {
|
|
pub fn new(field: String, code: String) -> Result<Self, ValidationError> {
|
|
let value = Self { field, code };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.field.is_empty() { return Err(ValidationError::new("field", "required")); }
|
|
if !self.field.is_empty() && self.field.len() < 1 { return Err(ValidationError::new("field", "min_length")); }
|
|
if self.field.len() > 128 { return Err(ValidationError::new("field", "max_length")); }
|
|
if self.code.is_empty() { return Err(ValidationError::new("code", "required")); }
|
|
if !self.code.is_empty() && self.code.len() < 1 { return Err(ValidationError::new("code", "min_length")); }
|
|
if self.code.len() > 64 { return Err(ValidationError::new("code", "max_length")); }
|
|
Ok(())
|
|
}
|
|
pub fn field(&self) -> &String { &self.field }
|
|
pub fn code(&self) -> &String { &self.code }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct GatewayClipboardAudit {
|
|
version: String,
|
|
sessionId: String,
|
|
direction: String,
|
|
outcome: String,
|
|
textBytes: i64,
|
|
reason: String,
|
|
}
|
|
|
|
impl GatewayClipboardAudit {
|
|
pub fn new(version: String, sessionId: String, direction: String, outcome: String, textBytes: i64, reason: String) -> Result<Self, ValidationError> {
|
|
let value = Self { version, sessionId, direction, outcome, textBytes, reason };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.version != "1" { return Err(ValidationError::new("version", "invalid_value")); }
|
|
if self.sessionId.is_empty() { return Err(ValidationError::new("session_id", "required")); }
|
|
if !self.sessionId.is_empty() && self.sessionId.len() < 1 { return Err(ValidationError::new("session_id", "min_length")); }
|
|
if self.sessionId.len() > 128 { return Err(ValidationError::new("session_id", "max_length")); }
|
|
if self.direction != "client_to_provider" && self.direction != "provider_to_client" { return Err(ValidationError::new("direction", "invalid_value")); }
|
|
if self.outcome != "forwarded" && self.outcome != "suppressed" && self.outcome != "rejected" { return Err(ValidationError::new("outcome", "invalid_value")); }
|
|
if self.textBytes < 0 { return Err(ValidationError::new("text_bytes", "minimum")); }
|
|
if self.textBytes > 65536 { return Err(ValidationError::new("text_bytes", "maximum")); }
|
|
if self.reason != "forwarded" && self.reason != "loop" && self.reason != "policy" && self.reason != "rate" && self.reason != "provider" && self.reason != "malformed" { return Err(ValidationError::new("reason", "invalid_value")); }
|
|
Ok(())
|
|
}
|
|
pub fn version(&self) -> &String { &self.version }
|
|
pub fn sessionId(&self) -> &String { &self.sessionId }
|
|
pub fn direction(&self) -> &String { &self.direction }
|
|
pub fn outcome(&self) -> &String { &self.outcome }
|
|
pub fn textBytes(&self) -> &i64 { &self.textBytes }
|
|
pub fn reason(&self) -> &String { &self.reason }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct GatewayClipboardText {
|
|
direction: String,
|
|
text: String,
|
|
encoding: String,
|
|
loopToken: String,
|
|
}
|
|
|
|
impl GatewayClipboardText {
|
|
pub fn new(direction: String, text: String, encoding: String, loopToken: String) -> Result<Self, ValidationError> {
|
|
let value = Self { direction, text, encoding, loopToken };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.direction != "client_to_provider" && self.direction != "provider_to_client" { return Err(ValidationError::new("direction", "invalid_value")); }
|
|
if self.text.len() > 65536 { return Err(ValidationError::new("text", "max_length")); }
|
|
if self.text.as_bytes().len() > 65536 { return Err(ValidationError::new("text", "max_bytes")); }
|
|
if self.encoding != "utf-8" { return Err(ValidationError::new("encoding", "invalid_value")); }
|
|
if self.loopToken.is_empty() { return Err(ValidationError::new("loop_token", "required")); }
|
|
if !self.loopToken.is_empty() && self.loopToken.len() < 16 { return Err(ValidationError::new("loop_token", "min_length")); }
|
|
if self.loopToken.len() > 128 { return Err(ValidationError::new("loop_token", "max_length")); }
|
|
if !valid_base64_url(self.loopToken.as_str()) { return Err(ValidationError::new("loop_token", "invalid_format")); }
|
|
Ok(())
|
|
}
|
|
pub fn direction(&self) -> &String { &self.direction }
|
|
pub fn text(&self) -> &String { &self.text }
|
|
pub fn encoding(&self) -> &String { &self.encoding }
|
|
pub fn loopToken(&self) -> &String { &self.loopToken }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct GatewayDrain {
|
|
version: String,
|
|
gatewayId: String,
|
|
sequence: i64,
|
|
reason: String,
|
|
deadline: String,
|
|
}
|
|
|
|
impl GatewayDrain {
|
|
pub fn new(version: String, gatewayId: String, sequence: i64, reason: String, deadline: String) -> Result<Self, ValidationError> {
|
|
let value = Self { version, gatewayId, sequence, reason, deadline };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.version != "1" { return Err(ValidationError::new("version", "invalid_value")); }
|
|
if self.gatewayId.is_empty() { return Err(ValidationError::new("gateway_id", "required")); }
|
|
if !self.gatewayId.is_empty() && self.gatewayId.len() < 1 { return Err(ValidationError::new("gateway_id", "min_length")); }
|
|
if self.gatewayId.len() > 128 { return Err(ValidationError::new("gateway_id", "max_length")); }
|
|
if self.sequence < 1 { return Err(ValidationError::new("sequence", "minimum")); }
|
|
if self.reason.is_empty() { return Err(ValidationError::new("reason", "required")); }
|
|
if !self.reason.is_empty() && self.reason.len() < 1 { return Err(ValidationError::new("reason", "min_length")); }
|
|
if self.reason.len() > 256 { return Err(ValidationError::new("reason", "max_length")); }
|
|
if self.deadline.len() > 64 { return Err(ValidationError::new("deadline", "max_length")); }
|
|
if !valid_rfc3339_utc(self.deadline.as_str()) { return Err(ValidationError::new("deadline", "invalid_time")); }
|
|
Ok(())
|
|
}
|
|
pub fn version(&self) -> &String { &self.version }
|
|
pub fn gatewayId(&self) -> &String { &self.gatewayId }
|
|
pub fn sequence(&self) -> &i64 { &self.sequence }
|
|
pub fn reason(&self) -> &String { &self.reason }
|
|
pub fn deadline(&self) -> &String { &self.deadline }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct GatewayHeartbeat {
|
|
version: String,
|
|
gatewayId: String,
|
|
sequence: i64,
|
|
observedAt: String,
|
|
activeConnections: i64,
|
|
egressKbps: i64,
|
|
state: String,
|
|
telemetry: GatewayTelemetry,
|
|
}
|
|
|
|
impl GatewayHeartbeat {
|
|
pub fn new(version: String, gatewayId: String, sequence: i64, observedAt: String, activeConnections: i64, egressKbps: i64, state: String, telemetry: GatewayTelemetry) -> Result<Self, ValidationError> {
|
|
let value = Self { version, gatewayId, sequence, observedAt, activeConnections, egressKbps, state, telemetry };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.version != "1" { return Err(ValidationError::new("version", "invalid_value")); }
|
|
if self.gatewayId.is_empty() { return Err(ValidationError::new("gateway_id", "required")); }
|
|
if !self.gatewayId.is_empty() && self.gatewayId.len() < 1 { return Err(ValidationError::new("gateway_id", "min_length")); }
|
|
if self.gatewayId.len() > 128 { return Err(ValidationError::new("gateway_id", "max_length")); }
|
|
if self.sequence < 1 { return Err(ValidationError::new("sequence", "minimum")); }
|
|
if self.observedAt.len() > 64 { return Err(ValidationError::new("observed_at", "max_length")); }
|
|
if !valid_rfc3339_utc(self.observedAt.as_str()) { return Err(ValidationError::new("observed_at", "invalid_time")); }
|
|
if self.activeConnections < 0 { return Err(ValidationError::new("active_connections", "minimum")); }
|
|
if self.activeConnections > 1000000 { return Err(ValidationError::new("active_connections", "maximum")); }
|
|
if self.egressKbps < 0 { return Err(ValidationError::new("egress_kbps", "minimum")); }
|
|
if self.egressKbps > 1000000000 { return Err(ValidationError::new("egress_kbps", "maximum")); }
|
|
if self.state != "ready" && self.state != "draining" && self.state != "offline" { return Err(ValidationError::new("state", "invalid_value")); }
|
|
self.telemetry.validate().map_err(|_| ValidationError::new("telemetry", "invalid_object"))?;
|
|
Ok(())
|
|
}
|
|
pub fn version(&self) -> &String { &self.version }
|
|
pub fn gatewayId(&self) -> &String { &self.gatewayId }
|
|
pub fn sequence(&self) -> &i64 { &self.sequence }
|
|
pub fn observedAt(&self) -> &String { &self.observedAt }
|
|
pub fn activeConnections(&self) -> &i64 { &self.activeConnections }
|
|
pub fn egressKbps(&self) -> &i64 { &self.egressKbps }
|
|
pub fn state(&self) -> &String { &self.state }
|
|
pub fn telemetry(&self) -> &GatewayTelemetry { &self.telemetry }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct GatewayRegistration {
|
|
version: String,
|
|
gatewayId: String,
|
|
instanceIdentity: String,
|
|
certificateIdentity: String,
|
|
publicIdentity: String,
|
|
address: String,
|
|
providerIdentity: String,
|
|
protocolMinVersion: i64,
|
|
protocolMaxVersion: i64,
|
|
connectionCapacity: i64,
|
|
bandwidthCapacityKbps: i64,
|
|
features: Vec<String>,
|
|
capabilities: CapabilityProfile,
|
|
}
|
|
|
|
impl GatewayRegistration {
|
|
pub fn new(version: String, gatewayId: String, instanceIdentity: String, certificateIdentity: String, publicIdentity: String, address: String, providerIdentity: String, protocolMinVersion: i64, protocolMaxVersion: i64, connectionCapacity: i64, bandwidthCapacityKbps: i64, features: Vec<String>, capabilities: CapabilityProfile) -> Result<Self, ValidationError> {
|
|
let value = Self { version, gatewayId, instanceIdentity, certificateIdentity, publicIdentity, address, providerIdentity, protocolMinVersion, protocolMaxVersion, connectionCapacity, bandwidthCapacityKbps, features, capabilities };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.version != "1" { return Err(ValidationError::new("version", "invalid_value")); }
|
|
if self.gatewayId.is_empty() { return Err(ValidationError::new("gateway_id", "required")); }
|
|
if !self.gatewayId.is_empty() && self.gatewayId.len() < 1 { return Err(ValidationError::new("gateway_id", "min_length")); }
|
|
if self.gatewayId.len() > 128 { return Err(ValidationError::new("gateway_id", "max_length")); }
|
|
if self.instanceIdentity.is_empty() { return Err(ValidationError::new("instance_identity", "required")); }
|
|
if !self.instanceIdentity.is_empty() && self.instanceIdentity.len() < 1 { return Err(ValidationError::new("instance_identity", "min_length")); }
|
|
if self.instanceIdentity.len() > 512 { return Err(ValidationError::new("instance_identity", "max_length")); }
|
|
if self.certificateIdentity.is_empty() { return Err(ValidationError::new("certificate_identity", "required")); }
|
|
if !self.certificateIdentity.is_empty() && self.certificateIdentity.len() < 1 { return Err(ValidationError::new("certificate_identity", "min_length")); }
|
|
if self.certificateIdentity.len() > 512 { return Err(ValidationError::new("certificate_identity", "max_length")); }
|
|
if self.publicIdentity.is_empty() { return Err(ValidationError::new("public_identity", "required")); }
|
|
if !self.publicIdentity.is_empty() && self.publicIdentity.len() < 1 { return Err(ValidationError::new("public_identity", "min_length")); }
|
|
if self.publicIdentity.len() > 256 { return Err(ValidationError::new("public_identity", "max_length")); }
|
|
if self.address.is_empty() { return Err(ValidationError::new("address", "required")); }
|
|
if !self.address.is_empty() && self.address.len() < 1 { return Err(ValidationError::new("address", "min_length")); }
|
|
if self.address.len() > 256 { return Err(ValidationError::new("address", "max_length")); }
|
|
if self.providerIdentity.is_empty() { return Err(ValidationError::new("provider_identity", "required")); }
|
|
if !self.providerIdentity.is_empty() && self.providerIdentity.len() < 1 { return Err(ValidationError::new("provider_identity", "min_length")); }
|
|
if self.providerIdentity.len() > 256 { return Err(ValidationError::new("provider_identity", "max_length")); }
|
|
if self.protocolMinVersion < 1 { return Err(ValidationError::new("protocol_min_version", "minimum")); }
|
|
if self.protocolMinVersion > 100 { return Err(ValidationError::new("protocol_min_version", "maximum")); }
|
|
if self.protocolMaxVersion < 1 { return Err(ValidationError::new("protocol_max_version", "minimum")); }
|
|
if self.protocolMaxVersion > 100 { return Err(ValidationError::new("protocol_max_version", "maximum")); }
|
|
if self.connectionCapacity < 1 { return Err(ValidationError::new("connection_capacity", "minimum")); }
|
|
if self.connectionCapacity > 1000000 { return Err(ValidationError::new("connection_capacity", "maximum")); }
|
|
if self.bandwidthCapacityKbps < 1 { return Err(ValidationError::new("bandwidth_capacity_kbps", "minimum")); }
|
|
if self.bandwidthCapacityKbps > 1000000000 { return Err(ValidationError::new("bandwidth_capacity_kbps", "maximum")); }
|
|
if self.features.len() > 64 { return Err(ValidationError::new("features", "max_items")); }
|
|
for item in self.features.iter() { if item.as_bytes().len() < 1 { return Err(ValidationError::new("features", "min_item_length")); } }
|
|
for item in self.features.iter() { if item.as_bytes().len() > 64 { return Err(ValidationError::new("features", "max_item_length")); } }
|
|
self.capabilities.validate().map_err(|_| ValidationError::new("capabilities", "invalid_object"))?;
|
|
if self.protocolMinVersion > self.protocolMaxVersion { return Err(ValidationError::new("protocol_version", "invalid_order")); }
|
|
Ok(())
|
|
}
|
|
pub fn version(&self) -> &String { &self.version }
|
|
pub fn gatewayId(&self) -> &String { &self.gatewayId }
|
|
pub fn instanceIdentity(&self) -> &String { &self.instanceIdentity }
|
|
pub fn certificateIdentity(&self) -> &String { &self.certificateIdentity }
|
|
pub fn publicIdentity(&self) -> &String { &self.publicIdentity }
|
|
pub fn address(&self) -> &String { &self.address }
|
|
pub fn providerIdentity(&self) -> &String { &self.providerIdentity }
|
|
pub fn protocolMinVersion(&self) -> &i64 { &self.protocolMinVersion }
|
|
pub fn protocolMaxVersion(&self) -> &i64 { &self.protocolMaxVersion }
|
|
pub fn connectionCapacity(&self) -> &i64 { &self.connectionCapacity }
|
|
pub fn bandwidthCapacityKbps(&self) -> &i64 { &self.bandwidthCapacityKbps }
|
|
pub fn features(&self) -> &Vec<String> { &self.features }
|
|
pub fn capabilities(&self) -> &CapabilityProfile { &self.capabilities }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct GatewayTelemetry {
|
|
admittedSessions: i64,
|
|
admissionRejects: i64,
|
|
reconnects: i64,
|
|
drainTransitions: i64,
|
|
mediaDrops: i64,
|
|
mediaPackets: i64,
|
|
mediaBytes: i64,
|
|
queueDelayMicros: i64,
|
|
processingDelayMicros: i64,
|
|
processingSamples: i64,
|
|
pacingDelayMicros: i64,
|
|
providerErrors: i64,
|
|
inputRejected: i64,
|
|
controlRttMicros: i64,
|
|
controlJitterMicros: i64,
|
|
controlLossPpm: i64,
|
|
pendingReliable: i64,
|
|
providerState: String,
|
|
}
|
|
|
|
impl GatewayTelemetry {
|
|
pub fn new(admittedSessions: i64, admissionRejects: i64, reconnects: i64, drainTransitions: i64, mediaDrops: i64, mediaPackets: i64, mediaBytes: i64, queueDelayMicros: i64, processingDelayMicros: i64, processingSamples: i64, pacingDelayMicros: i64, providerErrors: i64, inputRejected: i64, controlRttMicros: i64, controlJitterMicros: i64, controlLossPpm: i64, pendingReliable: i64, providerState: String) -> Result<Self, ValidationError> {
|
|
let value = Self { admittedSessions, admissionRejects, reconnects, drainTransitions, mediaDrops, mediaPackets, mediaBytes, queueDelayMicros, processingDelayMicros, processingSamples, pacingDelayMicros, providerErrors, inputRejected, controlRttMicros, controlJitterMicros, controlLossPpm, pendingReliable, providerState };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.admittedSessions < 0 { return Err(ValidationError::new("admitted_sessions", "minimum")); }
|
|
if self.admittedSessions > 9223372036854775807 { return Err(ValidationError::new("admitted_sessions", "maximum")); }
|
|
if self.admissionRejects < 0 { return Err(ValidationError::new("admission_rejects", "minimum")); }
|
|
if self.admissionRejects > 9223372036854775807 { return Err(ValidationError::new("admission_rejects", "maximum")); }
|
|
if self.reconnects < 0 { return Err(ValidationError::new("reconnects", "minimum")); }
|
|
if self.reconnects > 9223372036854775807 { return Err(ValidationError::new("reconnects", "maximum")); }
|
|
if self.drainTransitions < 0 { return Err(ValidationError::new("drain_transitions", "minimum")); }
|
|
if self.drainTransitions > 9223372036854775807 { return Err(ValidationError::new("drain_transitions", "maximum")); }
|
|
if self.mediaDrops < 0 { return Err(ValidationError::new("media_drops", "minimum")); }
|
|
if self.mediaDrops > 9223372036854775807 { return Err(ValidationError::new("media_drops", "maximum")); }
|
|
if self.mediaPackets < 0 { return Err(ValidationError::new("media_packets", "minimum")); }
|
|
if self.mediaPackets > 9223372036854775807 { return Err(ValidationError::new("media_packets", "maximum")); }
|
|
if self.mediaBytes < 0 { return Err(ValidationError::new("media_bytes", "minimum")); }
|
|
if self.mediaBytes > 9223372036854775807 { return Err(ValidationError::new("media_bytes", "maximum")); }
|
|
if self.queueDelayMicros < 0 { return Err(ValidationError::new("queue_delay_micros", "minimum")); }
|
|
if self.queueDelayMicros > 9223372036854775807 { return Err(ValidationError::new("queue_delay_micros", "maximum")); }
|
|
if self.processingDelayMicros < 0 { return Err(ValidationError::new("processing_delay_micros", "minimum")); }
|
|
if self.processingDelayMicros > 9223372036854775807 { return Err(ValidationError::new("processing_delay_micros", "maximum")); }
|
|
if self.processingSamples < 0 { return Err(ValidationError::new("processing_samples", "minimum")); }
|
|
if self.processingSamples > 9223372036854775807 { return Err(ValidationError::new("processing_samples", "maximum")); }
|
|
if self.pacingDelayMicros < 0 { return Err(ValidationError::new("pacing_delay_micros", "minimum")); }
|
|
if self.pacingDelayMicros > 9223372036854775807 { return Err(ValidationError::new("pacing_delay_micros", "maximum")); }
|
|
if self.providerErrors < 0 { return Err(ValidationError::new("provider_errors", "minimum")); }
|
|
if self.providerErrors > 9223372036854775807 { return Err(ValidationError::new("provider_errors", "maximum")); }
|
|
if self.inputRejected < 0 { return Err(ValidationError::new("input_rejected", "minimum")); }
|
|
if self.inputRejected > 9223372036854775807 { return Err(ValidationError::new("input_rejected", "maximum")); }
|
|
if self.controlRttMicros < 0 { return Err(ValidationError::new("control_rtt_micros", "minimum")); }
|
|
if self.controlRttMicros > 9223372036854775807 { return Err(ValidationError::new("control_rtt_micros", "maximum")); }
|
|
if self.controlJitterMicros < 0 { return Err(ValidationError::new("control_jitter_micros", "minimum")); }
|
|
if self.controlJitterMicros > 9223372036854775807 { return Err(ValidationError::new("control_jitter_micros", "maximum")); }
|
|
if self.controlLossPpm < 0 { return Err(ValidationError::new("control_loss_ppm", "minimum")); }
|
|
if self.controlLossPpm > 1000000 { return Err(ValidationError::new("control_loss_ppm", "maximum")); }
|
|
if self.pendingReliable < 0 { return Err(ValidationError::new("pending_reliable", "minimum")); }
|
|
if self.pendingReliable > 9223372036854775807 { return Err(ValidationError::new("pending_reliable", "maximum")); }
|
|
if self.providerState != "unknown" && self.providerState != "starting" && self.providerState != "ready" && self.providerState != "disconnected" && self.providerState != "terminating" && self.providerState != "terminated" && self.providerState != "cleanup_pending" && self.providerState != "failed" { return Err(ValidationError::new("provider_state", "invalid_value")); }
|
|
Ok(())
|
|
}
|
|
pub fn admittedSessions(&self) -> &i64 { &self.admittedSessions }
|
|
pub fn admissionRejects(&self) -> &i64 { &self.admissionRejects }
|
|
pub fn reconnects(&self) -> &i64 { &self.reconnects }
|
|
pub fn drainTransitions(&self) -> &i64 { &self.drainTransitions }
|
|
pub fn mediaDrops(&self) -> &i64 { &self.mediaDrops }
|
|
pub fn mediaPackets(&self) -> &i64 { &self.mediaPackets }
|
|
pub fn mediaBytes(&self) -> &i64 { &self.mediaBytes }
|
|
pub fn queueDelayMicros(&self) -> &i64 { &self.queueDelayMicros }
|
|
pub fn processingDelayMicros(&self) -> &i64 { &self.processingDelayMicros }
|
|
pub fn processingSamples(&self) -> &i64 { &self.processingSamples }
|
|
pub fn pacingDelayMicros(&self) -> &i64 { &self.pacingDelayMicros }
|
|
pub fn providerErrors(&self) -> &i64 { &self.providerErrors }
|
|
pub fn inputRejected(&self) -> &i64 { &self.inputRejected }
|
|
pub fn controlRttMicros(&self) -> &i64 { &self.controlRttMicros }
|
|
pub fn controlJitterMicros(&self) -> &i64 { &self.controlJitterMicros }
|
|
pub fn controlLossPpm(&self) -> &i64 { &self.controlLossPpm }
|
|
pub fn pendingReliable(&self) -> &i64 { &self.pendingReliable }
|
|
pub fn providerState(&self) -> &String { &self.providerState }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct GrantReference {
|
|
opaqueValue: String,
|
|
expiresAt: String,
|
|
audience: String,
|
|
}
|
|
|
|
impl GrantReference {
|
|
pub fn new(opaqueValue: String, expiresAt: String, audience: String) -> Result<Self, ValidationError> {
|
|
let value = Self { opaqueValue, expiresAt, audience };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.opaqueValue.is_empty() { return Err(ValidationError::new("opaque_value", "required")); }
|
|
if !self.opaqueValue.is_empty() && self.opaqueValue.len() < 43 { return Err(ValidationError::new("opaque_value", "min_length")); }
|
|
if self.opaqueValue.len() > 256 { return Err(ValidationError::new("opaque_value", "max_length")); }
|
|
if self.expiresAt.len() > 64 { return Err(ValidationError::new("expires_at", "max_length")); }
|
|
if !valid_rfc3339_utc(self.expiresAt.as_str()) { return Err(ValidationError::new("expires_at", "invalid_time")); }
|
|
if self.audience.is_empty() { return Err(ValidationError::new("audience", "required")); }
|
|
if !self.audience.is_empty() && self.audience.len() < 1 { return Err(ValidationError::new("audience", "min_length")); }
|
|
if self.audience.len() > 128 { return Err(ValidationError::new("audience", "max_length")); }
|
|
Ok(())
|
|
}
|
|
pub fn opaqueValue(&self) -> &String { &self.opaqueValue }
|
|
pub fn expiresAt(&self) -> &String { &self.expiresAt }
|
|
pub fn audience(&self) -> &String { &self.audience }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct LoginRequest {
|
|
provider: Option<String>,
|
|
username: String,
|
|
password: String,
|
|
}
|
|
|
|
impl LoginRequest {
|
|
pub fn new(provider: Option<String>, username: String, password: String) -> Result<Self, ValidationError> {
|
|
let value = Self { provider, username, password };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if let Some(value) = &self.provider {
|
|
if value != "ldap" && value != "local" { return Err(ValidationError::new("provider", "invalid_value")); }
|
|
}
|
|
if self.username.is_empty() { return Err(ValidationError::new("username", "required")); }
|
|
if !self.username.is_empty() && self.username.len() < 1 { return Err(ValidationError::new("username", "min_length")); }
|
|
if self.username.len() > 256 { return Err(ValidationError::new("username", "max_length")); }
|
|
if self.password.is_empty() { return Err(ValidationError::new("password", "required")); }
|
|
if !self.password.is_empty() && self.password.len() < 1 { return Err(ValidationError::new("password", "min_length")); }
|
|
if self.password.len() > 1024 { return Err(ValidationError::new("password", "max_length")); }
|
|
Ok(())
|
|
}
|
|
pub fn provider(&self) -> &Option<String> { &self.provider }
|
|
pub fn username(&self) -> &String { &self.username }
|
|
pub fn password(&self) -> &String { &self.password }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ManifestBounds {
|
|
minimumKbps: i64,
|
|
targetKbps: i64,
|
|
maximumKbps: i64,
|
|
}
|
|
|
|
impl ManifestBounds {
|
|
pub fn new(minimumKbps: i64, targetKbps: i64, maximumKbps: i64) -> Result<Self, ValidationError> {
|
|
let value = Self { minimumKbps, targetKbps, maximumKbps };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.minimumKbps < 1 { return Err(ValidationError::new("minimum_kbps", "minimum")); }
|
|
if self.minimumKbps > 100000000 { return Err(ValidationError::new("minimum_kbps", "maximum")); }
|
|
if self.targetKbps < 1 { return Err(ValidationError::new("target_kbps", "minimum")); }
|
|
if self.targetKbps > 100000000 { return Err(ValidationError::new("target_kbps", "maximum")); }
|
|
if self.maximumKbps < 1 { return Err(ValidationError::new("maximum_kbps", "minimum")); }
|
|
if self.maximumKbps > 100000000 { return Err(ValidationError::new("maximum_kbps", "maximum")); }
|
|
if self.minimumKbps > self.targetKbps || self.targetKbps > self.maximumKbps { return Err(ValidationError::new("bounds", "invalid_order")); }
|
|
Ok(())
|
|
}
|
|
pub fn minimumKbps(&self) -> &i64 { &self.minimumKbps }
|
|
pub fn targetKbps(&self) -> &i64 { &self.targetKbps }
|
|
pub fn maximumKbps(&self) -> &i64 { &self.maximumKbps }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ManifestGateway {
|
|
id: String,
|
|
addresses: Vec<String>,
|
|
publicIdentity: String,
|
|
}
|
|
|
|
impl ManifestGateway {
|
|
pub fn new(id: String, addresses: Vec<String>, publicIdentity: String) -> Result<Self, ValidationError> {
|
|
let value = Self { id, addresses, publicIdentity };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.id.is_empty() { return Err(ValidationError::new("id", "required")); }
|
|
if !self.id.is_empty() && self.id.len() < 1 { return Err(ValidationError::new("id", "min_length")); }
|
|
if self.id.len() > 128 { return Err(ValidationError::new("id", "max_length")); }
|
|
if self.addresses.len() < 1 { return Err(ValidationError::new("addresses", "min_items")); }
|
|
if self.addresses.len() > 4 { return Err(ValidationError::new("addresses", "max_items")); }
|
|
for item in self.addresses.iter() { if item.as_bytes().len() < 1 { return Err(ValidationError::new("addresses", "min_item_length")); } }
|
|
for item in self.addresses.iter() { if item.as_bytes().len() > 256 { return Err(ValidationError::new("addresses", "max_item_length")); } }
|
|
if self.publicIdentity.is_empty() { return Err(ValidationError::new("public_identity", "required")); }
|
|
if !self.publicIdentity.is_empty() && self.publicIdentity.len() < 1 { return Err(ValidationError::new("public_identity", "min_length")); }
|
|
if self.publicIdentity.len() > 256 { return Err(ValidationError::new("public_identity", "max_length")); }
|
|
Ok(())
|
|
}
|
|
pub fn id(&self) -> &String { &self.id }
|
|
pub fn addresses(&self) -> &Vec<String> { &self.addresses }
|
|
pub fn publicIdentity(&self) -> &String { &self.publicIdentity }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ManifestProfile {
|
|
id: String,
|
|
bounds: ManifestBounds,
|
|
displayMode: Option<DisplayMode>,
|
|
}
|
|
|
|
impl ManifestProfile {
|
|
pub fn new(id: String, bounds: ManifestBounds, displayMode: Option<DisplayMode>) -> Result<Self, ValidationError> {
|
|
let value = Self { id, bounds, displayMode };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.id.is_empty() { return Err(ValidationError::new("id", "required")); }
|
|
if !self.id.is_empty() && self.id.len() < 1 { return Err(ValidationError::new("id", "min_length")); }
|
|
if self.id.len() > 128 { return Err(ValidationError::new("id", "max_length")); }
|
|
self.bounds.validate().map_err(|_| ValidationError::new("bounds", "invalid_object"))?;
|
|
if let Some(value) = &self.displayMode {
|
|
value.validate().map_err(|_| ValidationError::new("display_mode", "invalid_object"))?;
|
|
}
|
|
Ok(())
|
|
}
|
|
pub fn id(&self) -> &String { &self.id }
|
|
pub fn bounds(&self) -> &ManifestBounds { &self.bounds }
|
|
pub fn displayMode(&self) -> &Option<DisplayMode> { &self.displayMode }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ManifestTunnel {
|
|
versions: Vec<String>,
|
|
features: Vec<String>,
|
|
}
|
|
|
|
impl ManifestTunnel {
|
|
pub fn new(versions: Vec<String>, features: Vec<String>) -> Result<Self, ValidationError> {
|
|
let value = Self { versions, features };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.versions.len() < 1 { return Err(ValidationError::new("versions", "min_items")); }
|
|
if self.versions.len() > 4 { return Err(ValidationError::new("versions", "max_items")); }
|
|
for item in self.versions.iter() { if item.as_bytes().len() < 1 { return Err(ValidationError::new("versions", "min_item_length")); } }
|
|
for item in self.versions.iter() { if item.as_bytes().len() > 64 { return Err(ValidationError::new("versions", "max_item_length")); } }
|
|
if self.features.len() > 32 { return Err(ValidationError::new("features", "max_items")); }
|
|
for item in self.features.iter() { if item.as_bytes().len() < 1 { return Err(ValidationError::new("features", "min_item_length")); } }
|
|
for item in self.features.iter() { if item.as_bytes().len() > 64 { return Err(ValidationError::new("features", "max_item_length")); } }
|
|
Ok(())
|
|
}
|
|
pub fn versions(&self) -> &Vec<String> { &self.versions }
|
|
pub fn features(&self) -> &Vec<String> { &self.features }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct NativeAuthenticatedSession {
|
|
username: String,
|
|
provider: String,
|
|
roles: Vec<String>,
|
|
role: String,
|
|
nativeIdentity: NativeSessionIdentity,
|
|
}
|
|
|
|
impl NativeAuthenticatedSession {
|
|
pub fn new(username: String, provider: String, roles: Vec<String>, role: String, nativeIdentity: NativeSessionIdentity) -> Result<Self, ValidationError> {
|
|
let value = Self { username, provider, roles, role, nativeIdentity };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.username.is_empty() { return Err(ValidationError::new("username", "required")); }
|
|
if !self.username.is_empty() && self.username.len() < 1 { return Err(ValidationError::new("username", "min_length")); }
|
|
if self.username.len() > 256 { return Err(ValidationError::new("username", "max_length")); }
|
|
if self.provider.is_empty() { return Err(ValidationError::new("provider", "required")); }
|
|
if !self.provider.is_empty() && self.provider.len() < 1 { return Err(ValidationError::new("provider", "min_length")); }
|
|
if self.provider.len() > 64 { return Err(ValidationError::new("provider", "max_length")); }
|
|
if self.roles.len() > 16 { return Err(ValidationError::new("roles", "max_items")); }
|
|
for item in self.roles.iter() { if item.as_bytes().len() < 1 { return Err(ValidationError::new("roles", "min_item_length")); } }
|
|
for item in self.roles.iter() { if item.as_bytes().len() > 64 { return Err(ValidationError::new("roles", "max_item_length")); } }
|
|
for item in self.roles.iter() { if item.as_bytes().len() > 64 { return Err(ValidationError::new("roles", "max_item_bytes")); } }
|
|
if self.role != "user" && self.role != "admin" { return Err(ValidationError::new("role", "invalid_value")); }
|
|
self.nativeIdentity.validate().map_err(|_| ValidationError::new("native_identity", "invalid_object"))?;
|
|
Ok(())
|
|
}
|
|
pub fn username(&self) -> &String { &self.username }
|
|
pub fn provider(&self) -> &String { &self.provider }
|
|
pub fn roles(&self) -> &Vec<String> { &self.roles }
|
|
pub fn role(&self) -> &String { &self.role }
|
|
pub fn nativeIdentity(&self) -> &NativeSessionIdentity { &self.nativeIdentity }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct NativeCredential {
|
|
deviceId: Option<String>,
|
|
familyId: String,
|
|
accessToken: String,
|
|
refreshToken: String,
|
|
expiresAt: String,
|
|
refreshExpiresAt: Option<String>,
|
|
}
|
|
|
|
impl NativeCredential {
|
|
pub fn new(deviceId: Option<String>, familyId: String, accessToken: String, refreshToken: String, expiresAt: String, refreshExpiresAt: Option<String>) -> Result<Self, ValidationError> {
|
|
let value = Self { deviceId, familyId, accessToken, refreshToken, expiresAt, refreshExpiresAt };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if let Some(value) = &self.deviceId {
|
|
if value.len() > 128 { return Err(ValidationError::new("device_id", "max_length")); }
|
|
}
|
|
if self.familyId.is_empty() { return Err(ValidationError::new("family_id", "required")); }
|
|
if !self.familyId.is_empty() && self.familyId.len() < 1 { return Err(ValidationError::new("family_id", "min_length")); }
|
|
if self.familyId.len() > 128 { return Err(ValidationError::new("family_id", "max_length")); }
|
|
if self.accessToken.is_empty() { return Err(ValidationError::new("access_token", "required")); }
|
|
if !self.accessToken.is_empty() && self.accessToken.len() < 1 { return Err(ValidationError::new("access_token", "min_length")); }
|
|
if self.accessToken.len() > 256 { return Err(ValidationError::new("access_token", "max_length")); }
|
|
if self.refreshToken.is_empty() { return Err(ValidationError::new("refresh_token", "required")); }
|
|
if !self.refreshToken.is_empty() && self.refreshToken.len() < 1 { return Err(ValidationError::new("refresh_token", "min_length")); }
|
|
if self.refreshToken.len() > 256 { return Err(ValidationError::new("refresh_token", "max_length")); }
|
|
if self.expiresAt.len() > 64 { return Err(ValidationError::new("expires_at", "max_length")); }
|
|
if !valid_rfc3339_utc(self.expiresAt.as_str()) { return Err(ValidationError::new("expires_at", "invalid_time")); }
|
|
if let Some(value) = &self.refreshExpiresAt {
|
|
if value.len() > 64 { return Err(ValidationError::new("refresh_expires_at", "max_length")); }
|
|
if !valid_rfc3339_utc(value.as_str()) { return Err(ValidationError::new("refresh_expires_at", "invalid_time")); }
|
|
}
|
|
Ok(())
|
|
}
|
|
pub fn deviceId(&self) -> &Option<String> { &self.deviceId }
|
|
pub fn familyId(&self) -> &String { &self.familyId }
|
|
pub fn accessToken(&self) -> &String { &self.accessToken }
|
|
pub fn refreshToken(&self) -> &String { &self.refreshToken }
|
|
pub fn expiresAt(&self) -> &String { &self.expiresAt }
|
|
pub fn refreshExpiresAt(&self) -> &Option<String> { &self.refreshExpiresAt }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct NativeSessionIdentity {
|
|
clientDeviceId: String,
|
|
deviceKeyId: String,
|
|
}
|
|
|
|
impl NativeSessionIdentity {
|
|
pub fn new(clientDeviceId: String, deviceKeyId: String) -> Result<Self, ValidationError> {
|
|
let value = Self { clientDeviceId, deviceKeyId };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.clientDeviceId.is_empty() { return Err(ValidationError::new("client_device_id", "required")); }
|
|
if !self.clientDeviceId.is_empty() && self.clientDeviceId.len() < 1 { return Err(ValidationError::new("client_device_id", "min_length")); }
|
|
if self.clientDeviceId.len() > 128 { return Err(ValidationError::new("client_device_id", "max_length")); }
|
|
if self.deviceKeyId.is_empty() { return Err(ValidationError::new("device_key_id", "required")); }
|
|
if !self.deviceKeyId.is_empty() && self.deviceKeyId.len() < 1 { return Err(ValidationError::new("device_key_id", "min_length")); }
|
|
if self.deviceKeyId.len() > 128 { return Err(ValidationError::new("device_key_id", "max_length")); }
|
|
Ok(())
|
|
}
|
|
pub fn clientDeviceId(&self) -> &String { &self.clientDeviceId }
|
|
pub fn deviceKeyId(&self) -> &String { &self.deviceKeyId }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct NativeTunnelCredential {
|
|
clientDeviceId: String,
|
|
deviceKeyId: String,
|
|
certificateChainPem: String,
|
|
trustBundlePem: String,
|
|
expiresAt: String,
|
|
}
|
|
|
|
impl NativeTunnelCredential {
|
|
pub fn new(clientDeviceId: String, deviceKeyId: String, certificateChainPem: String, trustBundlePem: String, expiresAt: String) -> Result<Self, ValidationError> {
|
|
let value = Self { clientDeviceId, deviceKeyId, certificateChainPem, trustBundlePem, expiresAt };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.clientDeviceId.is_empty() { return Err(ValidationError::new("client_device_id", "required")); }
|
|
if !self.clientDeviceId.is_empty() && self.clientDeviceId.len() < 1 { return Err(ValidationError::new("client_device_id", "min_length")); }
|
|
if self.clientDeviceId.len() > 128 { return Err(ValidationError::new("client_device_id", "max_length")); }
|
|
if self.deviceKeyId.is_empty() { return Err(ValidationError::new("device_key_id", "required")); }
|
|
if !self.deviceKeyId.is_empty() && self.deviceKeyId.len() < 1 { return Err(ValidationError::new("device_key_id", "min_length")); }
|
|
if self.deviceKeyId.len() > 128 { return Err(ValidationError::new("device_key_id", "max_length")); }
|
|
if self.certificateChainPem.is_empty() { return Err(ValidationError::new("certificate_chain_pem", "required")); }
|
|
if !self.certificateChainPem.is_empty() && self.certificateChainPem.len() < 1 { return Err(ValidationError::new("certificate_chain_pem", "min_length")); }
|
|
if self.certificateChainPem.len() > 65536 { return Err(ValidationError::new("certificate_chain_pem", "max_length")); }
|
|
if self.trustBundlePem.is_empty() { return Err(ValidationError::new("trust_bundle_pem", "required")); }
|
|
if !self.trustBundlePem.is_empty() && self.trustBundlePem.len() < 1 { return Err(ValidationError::new("trust_bundle_pem", "min_length")); }
|
|
if self.trustBundlePem.len() > 65536 { return Err(ValidationError::new("trust_bundle_pem", "max_length")); }
|
|
if self.expiresAt.len() > 64 { return Err(ValidationError::new("expires_at", "max_length")); }
|
|
if !valid_rfc3339_utc(self.expiresAt.as_str()) { return Err(ValidationError::new("expires_at", "invalid_time")); }
|
|
Ok(())
|
|
}
|
|
pub fn clientDeviceId(&self) -> &String { &self.clientDeviceId }
|
|
pub fn deviceKeyId(&self) -> &String { &self.deviceKeyId }
|
|
pub fn certificateChainPem(&self) -> &String { &self.certificateChainPem }
|
|
pub fn trustBundlePem(&self) -> &String { &self.trustBundlePem }
|
|
pub fn expiresAt(&self) -> &String { &self.expiresAt }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct PageInfo {
|
|
limit: i64,
|
|
nextCursor: String,
|
|
}
|
|
|
|
impl PageInfo {
|
|
pub fn new(limit: i64, nextCursor: String) -> Result<Self, ValidationError> {
|
|
let value = Self { limit, nextCursor };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.limit < 1 { return Err(ValidationError::new("limit", "minimum")); }
|
|
if self.limit > 100 { return Err(ValidationError::new("limit", "maximum")); }
|
|
if self.nextCursor.len() > 512 { return Err(ValidationError::new("next_cursor", "max_length")); }
|
|
Ok(())
|
|
}
|
|
pub fn limit(&self) -> &i64 { &self.limit }
|
|
pub fn nextCursor(&self) -> &String { &self.nextCursor }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ProviderSessionWork {
|
|
version: String,
|
|
sessionId: String,
|
|
gatewayId: String,
|
|
reconnectSequence: i64,
|
|
expiresAt: String,
|
|
providerProfile: String,
|
|
providerIdentity: String,
|
|
policyVersionId: String,
|
|
streamPolicy: ProviderStreamPolicy,
|
|
applicationId: String,
|
|
clientId: String,
|
|
managementHost: String,
|
|
managementPort: i64,
|
|
streamHost: String,
|
|
streamPort: i64,
|
|
clientCertificatePem: String,
|
|
clientPrivateKeyPem: String,
|
|
serverCertificatePem: String,
|
|
clipboardPolicy: ClipboardPolicy,
|
|
providerApplicationTerminationAllowed: bool,
|
|
}
|
|
|
|
impl ProviderSessionWork {
|
|
pub fn new(version: String, sessionId: String, gatewayId: String, reconnectSequence: i64, expiresAt: String, providerProfile: String, providerIdentity: String, policyVersionId: String, streamPolicy: ProviderStreamPolicy, applicationId: String, clientId: String, managementHost: String, managementPort: i64, streamHost: String, streamPort: i64, clientCertificatePem: String, clientPrivateKeyPem: String, serverCertificatePem: String, clipboardPolicy: ClipboardPolicy, providerApplicationTerminationAllowed: bool) -> Result<Self, ValidationError> {
|
|
let value = Self { version, sessionId, gatewayId, reconnectSequence, expiresAt, providerProfile, providerIdentity, policyVersionId, streamPolicy, applicationId, clientId, managementHost, managementPort, streamHost, streamPort, clientCertificatePem, clientPrivateKeyPem, serverCertificatePem, clipboardPolicy, providerApplicationTerminationAllowed };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.version != "1" { return Err(ValidationError::new("version", "invalid_value")); }
|
|
if self.sessionId.is_empty() { return Err(ValidationError::new("session_id", "required")); }
|
|
if !self.sessionId.is_empty() && self.sessionId.len() < 1 { return Err(ValidationError::new("session_id", "min_length")); }
|
|
if self.sessionId.len() > 128 { return Err(ValidationError::new("session_id", "max_length")); }
|
|
if self.gatewayId.is_empty() { return Err(ValidationError::new("gateway_id", "required")); }
|
|
if !self.gatewayId.is_empty() && self.gatewayId.len() < 1 { return Err(ValidationError::new("gateway_id", "min_length")); }
|
|
if self.gatewayId.len() > 128 { return Err(ValidationError::new("gateway_id", "max_length")); }
|
|
if self.reconnectSequence < 0 { return Err(ValidationError::new("reconnect_sequence", "minimum")); }
|
|
if self.expiresAt.len() > 64 { return Err(ValidationError::new("expires_at", "max_length")); }
|
|
if !valid_rfc3339_utc(self.expiresAt.as_str()) { return Err(ValidationError::new("expires_at", "invalid_time")); }
|
|
if self.providerProfile != "apollo" { return Err(ValidationError::new("provider_profile", "invalid_value")); }
|
|
if self.providerIdentity.is_empty() { return Err(ValidationError::new("provider_identity", "required")); }
|
|
if !self.providerIdentity.is_empty() && self.providerIdentity.len() < 1 { return Err(ValidationError::new("provider_identity", "min_length")); }
|
|
if self.providerIdentity.len() > 256 { return Err(ValidationError::new("provider_identity", "max_length")); }
|
|
if self.policyVersionId.is_empty() { return Err(ValidationError::new("policy_version_id", "required")); }
|
|
if !self.policyVersionId.is_empty() && self.policyVersionId.len() < 1 { return Err(ValidationError::new("policy_version_id", "min_length")); }
|
|
if self.policyVersionId.len() > 128 { return Err(ValidationError::new("policy_version_id", "max_length")); }
|
|
self.streamPolicy.validate().map_err(|_| ValidationError::new("stream_policy", "invalid_object"))?;
|
|
if self.applicationId.is_empty() { return Err(ValidationError::new("application_id", "required")); }
|
|
if !self.applicationId.is_empty() && self.applicationId.len() < 1 { return Err(ValidationError::new("application_id", "min_length")); }
|
|
if self.applicationId.len() > 128 { return Err(ValidationError::new("application_id", "max_length")); }
|
|
if self.clientId.is_empty() { return Err(ValidationError::new("client_id", "required")); }
|
|
if !self.clientId.is_empty() && self.clientId.len() < 1 { return Err(ValidationError::new("client_id", "min_length")); }
|
|
if self.clientId.len() > 128 { return Err(ValidationError::new("client_id", "max_length")); }
|
|
if self.managementHost.is_empty() { return Err(ValidationError::new("management_host", "required")); }
|
|
if !self.managementHost.is_empty() && self.managementHost.len() < 1 { return Err(ValidationError::new("management_host", "min_length")); }
|
|
if self.managementHost.len() > 256 { return Err(ValidationError::new("management_host", "max_length")); }
|
|
if self.managementPort < 1 { return Err(ValidationError::new("management_port", "minimum")); }
|
|
if self.managementPort > 65535 { return Err(ValidationError::new("management_port", "maximum")); }
|
|
if self.streamHost.is_empty() { return Err(ValidationError::new("stream_host", "required")); }
|
|
if !self.streamHost.is_empty() && self.streamHost.len() < 1 { return Err(ValidationError::new("stream_host", "min_length")); }
|
|
if self.streamHost.len() > 256 { return Err(ValidationError::new("stream_host", "max_length")); }
|
|
if self.streamPort < 1 { return Err(ValidationError::new("stream_port", "minimum")); }
|
|
if self.streamPort > 65535 { return Err(ValidationError::new("stream_port", "maximum")); }
|
|
if self.clientCertificatePem.is_empty() { return Err(ValidationError::new("client_certificate_pem", "required")); }
|
|
if !self.clientCertificatePem.is_empty() && self.clientCertificatePem.len() < 1 { return Err(ValidationError::new("client_certificate_pem", "min_length")); }
|
|
if self.clientCertificatePem.len() > 32768 { return Err(ValidationError::new("client_certificate_pem", "max_length")); }
|
|
if self.clientPrivateKeyPem.is_empty() { return Err(ValidationError::new("client_private_key_pem", "required")); }
|
|
if !self.clientPrivateKeyPem.is_empty() && self.clientPrivateKeyPem.len() < 1 { return Err(ValidationError::new("client_private_key_pem", "min_length")); }
|
|
if self.clientPrivateKeyPem.len() > 32768 { return Err(ValidationError::new("client_private_key_pem", "max_length")); }
|
|
if self.serverCertificatePem.is_empty() { return Err(ValidationError::new("server_certificate_pem", "required")); }
|
|
if !self.serverCertificatePem.is_empty() && self.serverCertificatePem.len() < 1 { return Err(ValidationError::new("server_certificate_pem", "min_length")); }
|
|
if self.serverCertificatePem.len() > 32768 { return Err(ValidationError::new("server_certificate_pem", "max_length")); }
|
|
self.clipboardPolicy.validate().map_err(|_| ValidationError::new("clipboard_policy", "invalid_object"))?;
|
|
Ok(())
|
|
}
|
|
pub fn version(&self) -> &String { &self.version }
|
|
pub fn sessionId(&self) -> &String { &self.sessionId }
|
|
pub fn gatewayId(&self) -> &String { &self.gatewayId }
|
|
pub fn reconnectSequence(&self) -> &i64 { &self.reconnectSequence }
|
|
pub fn expiresAt(&self) -> &String { &self.expiresAt }
|
|
pub fn providerProfile(&self) -> &String { &self.providerProfile }
|
|
pub fn providerIdentity(&self) -> &String { &self.providerIdentity }
|
|
pub fn policyVersionId(&self) -> &String { &self.policyVersionId }
|
|
pub fn streamPolicy(&self) -> &ProviderStreamPolicy { &self.streamPolicy }
|
|
pub fn applicationId(&self) -> &String { &self.applicationId }
|
|
pub fn clientId(&self) -> &String { &self.clientId }
|
|
pub fn managementHost(&self) -> &String { &self.managementHost }
|
|
pub fn managementPort(&self) -> &i64 { &self.managementPort }
|
|
pub fn streamHost(&self) -> &String { &self.streamHost }
|
|
pub fn streamPort(&self) -> &i64 { &self.streamPort }
|
|
pub fn clientCertificatePem(&self) -> &String { &self.clientCertificatePem }
|
|
pub fn clientPrivateKeyPem(&self) -> &String { &self.clientPrivateKeyPem }
|
|
pub fn serverCertificatePem(&self) -> &String { &self.serverCertificatePem }
|
|
pub fn clipboardPolicy(&self) -> &ClipboardPolicy { &self.clipboardPolicy }
|
|
pub fn providerApplicationTerminationAllowed(&self) -> &bool { &self.providerApplicationTerminationAllowed }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ProviderState {
|
|
version: String,
|
|
sessionId: String,
|
|
state: String,
|
|
cleanupPending: bool,
|
|
channels: Vec<String>,
|
|
}
|
|
|
|
impl ProviderState {
|
|
pub fn new(version: String, sessionId: String, state: String, cleanupPending: bool, channels: Vec<String>) -> Result<Self, ValidationError> {
|
|
let value = Self { version, sessionId, state, cleanupPending, channels };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.version != "1" { return Err(ValidationError::new("version", "invalid_value")); }
|
|
if self.sessionId.is_empty() { return Err(ValidationError::new("session_id", "required")); }
|
|
if !self.sessionId.is_empty() && self.sessionId.len() < 1 { return Err(ValidationError::new("session_id", "min_length")); }
|
|
if self.sessionId.len() > 128 { return Err(ValidationError::new("session_id", "max_length")); }
|
|
if self.state != "starting" && self.state != "ready" && self.state != "disconnected" && self.state != "terminating" && self.state != "terminated" && self.state != "cleanup_pending" && self.state != "failed" { return Err(ValidationError::new("state", "invalid_value")); }
|
|
if self.channels.len() > 8 { return Err(ValidationError::new("channels", "max_items")); }
|
|
for item in self.channels.iter() { if item.as_bytes().len() < 1 { return Err(ValidationError::new("channels", "min_item_length")); } }
|
|
for item in self.channels.iter() { if item.as_bytes().len() > 64 { return Err(ValidationError::new("channels", "max_item_length")); } }
|
|
Ok(())
|
|
}
|
|
pub fn version(&self) -> &String { &self.version }
|
|
pub fn sessionId(&self) -> &String { &self.sessionId }
|
|
pub fn state(&self) -> &String { &self.state }
|
|
pub fn cleanupPending(&self) -> &bool { &self.cleanupPending }
|
|
pub fn channels(&self) -> &Vec<String> { &self.channels }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ProviderStreamPolicy {
|
|
resolutionWidth: i64,
|
|
resolutionHeight: i64,
|
|
fps: i64,
|
|
codec: String,
|
|
bitrateKbps: i64,
|
|
audioEnabled: bool,
|
|
}
|
|
|
|
impl ProviderStreamPolicy {
|
|
pub fn new(resolutionWidth: i64, resolutionHeight: i64, fps: i64, codec: String, bitrateKbps: i64, audioEnabled: bool) -> Result<Self, ValidationError> {
|
|
let value = Self { resolutionWidth, resolutionHeight, fps, codec, bitrateKbps, audioEnabled };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.resolutionWidth < 320 { return Err(ValidationError::new("resolution_width", "minimum")); }
|
|
if self.resolutionWidth > 16384 { return Err(ValidationError::new("resolution_width", "maximum")); }
|
|
if self.resolutionHeight < 200 { return Err(ValidationError::new("resolution_height", "minimum")); }
|
|
if self.resolutionHeight > 8640 { return Err(ValidationError::new("resolution_height", "maximum")); }
|
|
if self.fps < 1 { return Err(ValidationError::new("fps", "minimum")); }
|
|
if self.fps > 240 { return Err(ValidationError::new("fps", "maximum")); }
|
|
if self.codec != "H264" && self.codec != "HEVC" && self.codec != "AV1" { return Err(ValidationError::new("codec", "invalid_value")); }
|
|
if self.bitrateKbps < 100 { return Err(ValidationError::new("bitrate_kbps", "minimum")); }
|
|
if self.bitrateKbps > 1000000 { return Err(ValidationError::new("bitrate_kbps", "maximum")); }
|
|
Ok(())
|
|
}
|
|
pub fn resolutionWidth(&self) -> &i64 { &self.resolutionWidth }
|
|
pub fn resolutionHeight(&self) -> &i64 { &self.resolutionHeight }
|
|
pub fn fps(&self) -> &i64 { &self.fps }
|
|
pub fn codec(&self) -> &String { &self.codec }
|
|
pub fn bitrateKbps(&self) -> &i64 { &self.bitrateKbps }
|
|
pub fn audioEnabled(&self) -> &bool { &self.audioEnabled }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ReauthGrant {
|
|
token: String,
|
|
purpose: String,
|
|
expiresAt: String,
|
|
}
|
|
|
|
impl ReauthGrant {
|
|
pub fn new(token: String, purpose: String, expiresAt: String) -> Result<Self, ValidationError> {
|
|
let value = Self { token, purpose, expiresAt };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.token.is_empty() { return Err(ValidationError::new("token", "required")); }
|
|
if !self.token.is_empty() && self.token.len() < 1 { return Err(ValidationError::new("token", "min_length")); }
|
|
if self.token.len() > 256 { return Err(ValidationError::new("token", "max_length")); }
|
|
if self.purpose.is_empty() { return Err(ValidationError::new("purpose", "required")); }
|
|
if !self.purpose.is_empty() && self.purpose.len() < 1 { return Err(ValidationError::new("purpose", "min_length")); }
|
|
if self.purpose.len() > 64 { return Err(ValidationError::new("purpose", "max_length")); }
|
|
if self.expiresAt.len() > 64 { return Err(ValidationError::new("expires_at", "max_length")); }
|
|
if !valid_rfc3339_utc(self.expiresAt.as_str()) { return Err(ValidationError::new("expires_at", "invalid_time")); }
|
|
Ok(())
|
|
}
|
|
pub fn token(&self) -> &String { &self.token }
|
|
pub fn purpose(&self) -> &String { &self.purpose }
|
|
pub fn expiresAt(&self) -> &String { &self.expiresAt }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ReauthRequest {
|
|
password: String,
|
|
purpose: String,
|
|
}
|
|
|
|
impl ReauthRequest {
|
|
pub fn new(password: String, purpose: String) -> Result<Self, ValidationError> {
|
|
let value = Self { password, purpose };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.password.is_empty() { return Err(ValidationError::new("password", "required")); }
|
|
if !self.password.is_empty() && self.password.len() < 1 { return Err(ValidationError::new("password", "min_length")); }
|
|
if self.password.len() > 1024 { return Err(ValidationError::new("password", "max_length")); }
|
|
if self.purpose != "identity_change" && self.purpose != "key_change" && self.purpose != "backup_enable" && self.purpose != "external_database_tls_disabled" && self.purpose != "assignment_change" { return Err(ValidationError::new("purpose", "invalid_value")); }
|
|
Ok(())
|
|
}
|
|
pub fn password(&self) -> &String { &self.password }
|
|
pub fn purpose(&self) -> &String { &self.purpose }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ReconnectRequest {
|
|
clientDeviceId: String,
|
|
deviceKeyId: String,
|
|
expectedVersion: i64,
|
|
}
|
|
|
|
impl ReconnectRequest {
|
|
pub fn new(clientDeviceId: String, deviceKeyId: String, expectedVersion: i64) -> Result<Self, ValidationError> {
|
|
let value = Self { clientDeviceId, deviceKeyId, expectedVersion };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.clientDeviceId.is_empty() { return Err(ValidationError::new("client_device_id", "required")); }
|
|
if !self.clientDeviceId.is_empty() && self.clientDeviceId.len() < 1 { return Err(ValidationError::new("client_device_id", "min_length")); }
|
|
if self.clientDeviceId.len() > 128 { return Err(ValidationError::new("client_device_id", "max_length")); }
|
|
if self.deviceKeyId.is_empty() { return Err(ValidationError::new("device_key_id", "required")); }
|
|
if !self.deviceKeyId.is_empty() && self.deviceKeyId.len() < 1 { return Err(ValidationError::new("device_key_id", "min_length")); }
|
|
if self.deviceKeyId.len() > 128 { return Err(ValidationError::new("device_key_id", "max_length")); }
|
|
if self.expectedVersion < 1 { return Err(ValidationError::new("expected_version", "minimum")); }
|
|
Ok(())
|
|
}
|
|
pub fn clientDeviceId(&self) -> &String { &self.clientDeviceId }
|
|
pub fn deviceKeyId(&self) -> &String { &self.deviceKeyId }
|
|
pub fn expectedVersion(&self) -> &i64 { &self.expectedVersion }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct RefreshRequest {
|
|
familyId: String,
|
|
refreshToken: String,
|
|
}
|
|
|
|
impl RefreshRequest {
|
|
pub fn new(familyId: String, refreshToken: String) -> Result<Self, ValidationError> {
|
|
let value = Self { familyId, refreshToken };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.familyId.is_empty() { return Err(ValidationError::new("family_id", "required")); }
|
|
if !self.familyId.is_empty() && self.familyId.len() < 1 { return Err(ValidationError::new("family_id", "min_length")); }
|
|
if self.familyId.len() > 128 { return Err(ValidationError::new("family_id", "max_length")); }
|
|
if self.refreshToken.is_empty() { return Err(ValidationError::new("refresh_token", "required")); }
|
|
if !self.refreshToken.is_empty() && self.refreshToken.len() < 1 { return Err(ValidationError::new("refresh_token", "min_length")); }
|
|
if self.refreshToken.len() > 256 { return Err(ValidationError::new("refresh_token", "max_length")); }
|
|
Ok(())
|
|
}
|
|
pub fn familyId(&self) -> &String { &self.familyId }
|
|
pub fn refreshToken(&self) -> &String { &self.refreshToken }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct Resource {
|
|
id: String,
|
|
kind: String,
|
|
name: String,
|
|
state: String,
|
|
assignmentState: Option<String>,
|
|
version: i64,
|
|
links: Vec<ResourceLink>,
|
|
}
|
|
|
|
impl Resource {
|
|
pub fn new(id: String, kind: String, name: String, state: String, assignmentState: Option<String>, version: i64, links: Vec<ResourceLink>) -> Result<Self, ValidationError> {
|
|
let value = Self { id, kind, name, state, assignmentState, version, links };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.id.is_empty() { return Err(ValidationError::new("id", "required")); }
|
|
if !self.id.is_empty() && self.id.len() < 1 { return Err(ValidationError::new("id", "min_length")); }
|
|
if self.id.len() > 128 { return Err(ValidationError::new("id", "max_length")); }
|
|
if self.kind.is_empty() { return Err(ValidationError::new("kind", "required")); }
|
|
if !self.kind.is_empty() && self.kind.len() < 1 { return Err(ValidationError::new("kind", "min_length")); }
|
|
if self.kind.len() > 64 { return Err(ValidationError::new("kind", "max_length")); }
|
|
if self.name.is_empty() { return Err(ValidationError::new("name", "required")); }
|
|
if !self.name.is_empty() && self.name.len() < 1 { return Err(ValidationError::new("name", "min_length")); }
|
|
if self.name.len() > 256 { return Err(ValidationError::new("name", "max_length")); }
|
|
if self.state.is_empty() { return Err(ValidationError::new("state", "required")); }
|
|
if !self.state.is_empty() && self.state.len() < 1 { return Err(ValidationError::new("state", "min_length")); }
|
|
if self.state.len() > 64 { return Err(ValidationError::new("state", "max_length")); }
|
|
if let Some(value) = &self.assignmentState {
|
|
if value.len() > 64 { return Err(ValidationError::new("assignment_state", "max_length")); }
|
|
}
|
|
if self.version < 1 { return Err(ValidationError::new("version", "minimum")); }
|
|
if self.links.len() > 16 { return Err(ValidationError::new("links", "max_items")); }
|
|
for item in self.links.iter() { item.validate().map_err(|_| ValidationError::new("links", "invalid_item"))?; }
|
|
Ok(())
|
|
}
|
|
pub fn id(&self) -> &String { &self.id }
|
|
pub fn kind(&self) -> &String { &self.kind }
|
|
pub fn name(&self) -> &String { &self.name }
|
|
pub fn state(&self) -> &String { &self.state }
|
|
pub fn assignmentState(&self) -> &Option<String> { &self.assignmentState }
|
|
pub fn version(&self) -> &i64 { &self.version }
|
|
pub fn links(&self) -> &Vec<ResourceLink> { &self.links }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ResourceLink {
|
|
typeValue: String,
|
|
id: String,
|
|
version: i64,
|
|
}
|
|
|
|
impl ResourceLink {
|
|
pub fn new(typeValue: String, id: String, version: i64) -> Result<Self, ValidationError> {
|
|
let value = Self { typeValue, id, version };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.typeValue.is_empty() { return Err(ValidationError::new("type", "required")); }
|
|
if !self.typeValue.is_empty() && self.typeValue.len() < 1 { return Err(ValidationError::new("type", "min_length")); }
|
|
if self.typeValue.len() > 64 { return Err(ValidationError::new("type", "max_length")); }
|
|
if self.id.is_empty() { return Err(ValidationError::new("id", "required")); }
|
|
if !self.id.is_empty() && self.id.len() < 1 { return Err(ValidationError::new("id", "min_length")); }
|
|
if self.id.len() > 128 { return Err(ValidationError::new("id", "max_length")); }
|
|
if self.version < 1 { return Err(ValidationError::new("version", "minimum")); }
|
|
Ok(())
|
|
}
|
|
pub fn typeValue(&self) -> &String { &self.typeValue }
|
|
pub fn id(&self) -> &String { &self.id }
|
|
pub fn version(&self) -> &i64 { &self.version }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct ResourceList {
|
|
assignedDesktops: Vec<AssignedDesktop>,
|
|
entitledPools: Vec<EntitledPool>,
|
|
page: PageInfo,
|
|
}
|
|
|
|
impl ResourceList {
|
|
pub fn new(assignedDesktops: Vec<AssignedDesktop>, entitledPools: Vec<EntitledPool>, page: PageInfo) -> Result<Self, ValidationError> {
|
|
let value = Self { assignedDesktops, entitledPools, page };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.assignedDesktops.len() > 100 { return Err(ValidationError::new("assigned_desktops", "max_items")); }
|
|
for item in self.assignedDesktops.iter() { item.validate().map_err(|_| ValidationError::new("assigned_desktops", "invalid_item"))?; }
|
|
if self.entitledPools.len() > 100 { return Err(ValidationError::new("entitled_pools", "max_items")); }
|
|
for item in self.entitledPools.iter() { item.validate().map_err(|_| ValidationError::new("entitled_pools", "invalid_item"))?; }
|
|
self.page.validate().map_err(|_| ValidationError::new("page", "invalid_object"))?;
|
|
Ok(())
|
|
}
|
|
pub fn assignedDesktops(&self) -> &Vec<AssignedDesktop> { &self.assignedDesktops }
|
|
pub fn entitledPools(&self) -> &Vec<EntitledPool> { &self.entitledPools }
|
|
pub fn page(&self) -> &PageInfo { &self.page }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct SessionAuthority {
|
|
version: String,
|
|
sessionId: String,
|
|
gatewayId: String,
|
|
audience: String,
|
|
reconnectSequence: i64,
|
|
expiresAt: String,
|
|
capabilities: CapabilityProfile,
|
|
providerProfile: String,
|
|
providerIdentity: String,
|
|
}
|
|
|
|
impl SessionAuthority {
|
|
pub fn new(version: String, sessionId: String, gatewayId: String, audience: String, reconnectSequence: i64, expiresAt: String, capabilities: CapabilityProfile, providerProfile: String, providerIdentity: String) -> Result<Self, ValidationError> {
|
|
let value = Self { version, sessionId, gatewayId, audience, reconnectSequence, expiresAt, capabilities, providerProfile, providerIdentity };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.version != "1" { return Err(ValidationError::new("version", "invalid_value")); }
|
|
if self.sessionId.is_empty() { return Err(ValidationError::new("session_id", "required")); }
|
|
if !self.sessionId.is_empty() && self.sessionId.len() < 1 { return Err(ValidationError::new("session_id", "min_length")); }
|
|
if self.sessionId.len() > 128 { return Err(ValidationError::new("session_id", "max_length")); }
|
|
if self.gatewayId.is_empty() { return Err(ValidationError::new("gateway_id", "required")); }
|
|
if !self.gatewayId.is_empty() && self.gatewayId.len() < 1 { return Err(ValidationError::new("gateway_id", "min_length")); }
|
|
if self.gatewayId.len() > 128 { return Err(ValidationError::new("gateway_id", "max_length")); }
|
|
if self.audience.is_empty() { return Err(ValidationError::new("audience", "required")); }
|
|
if !self.audience.is_empty() && self.audience.len() < 1 { return Err(ValidationError::new("audience", "min_length")); }
|
|
if self.audience.len() > 256 { return Err(ValidationError::new("audience", "max_length")); }
|
|
if self.reconnectSequence < 0 { return Err(ValidationError::new("reconnect_sequence", "minimum")); }
|
|
if self.expiresAt.len() > 64 { return Err(ValidationError::new("expires_at", "max_length")); }
|
|
if !valid_rfc3339_utc(self.expiresAt.as_str()) { return Err(ValidationError::new("expires_at", "invalid_time")); }
|
|
self.capabilities.validate().map_err(|_| ValidationError::new("capabilities", "invalid_object"))?;
|
|
if self.providerProfile != "apollo" { return Err(ValidationError::new("provider_profile", "invalid_value")); }
|
|
if self.providerIdentity.is_empty() { return Err(ValidationError::new("provider_identity", "required")); }
|
|
if !self.providerIdentity.is_empty() && self.providerIdentity.len() < 1 { return Err(ValidationError::new("provider_identity", "min_length")); }
|
|
if self.providerIdentity.len() > 256 { return Err(ValidationError::new("provider_identity", "max_length")); }
|
|
Ok(())
|
|
}
|
|
pub fn version(&self) -> &String { &self.version }
|
|
pub fn sessionId(&self) -> &String { &self.sessionId }
|
|
pub fn gatewayId(&self) -> &String { &self.gatewayId }
|
|
pub fn audience(&self) -> &String { &self.audience }
|
|
pub fn reconnectSequence(&self) -> &i64 { &self.reconnectSequence }
|
|
pub fn expiresAt(&self) -> &String { &self.expiresAt }
|
|
pub fn capabilities(&self) -> &CapabilityProfile { &self.capabilities }
|
|
pub fn providerProfile(&self) -> &String { &self.providerProfile }
|
|
pub fn providerIdentity(&self) -> &String { &self.providerIdentity }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct SessionRequest {
|
|
clientDeviceId: String,
|
|
deviceKeyId: String,
|
|
poolId: String,
|
|
idempotencyKey: String,
|
|
requestedDisplayMode: Option<DisplayMode>,
|
|
}
|
|
|
|
impl SessionRequest {
|
|
pub fn new(clientDeviceId: String, deviceKeyId: String, poolId: String, idempotencyKey: String, requestedDisplayMode: Option<DisplayMode>) -> Result<Self, ValidationError> {
|
|
let value = Self { clientDeviceId, deviceKeyId, poolId, idempotencyKey, requestedDisplayMode };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.clientDeviceId.is_empty() { return Err(ValidationError::new("client_device_id", "required")); }
|
|
if !self.clientDeviceId.is_empty() && self.clientDeviceId.len() < 1 { return Err(ValidationError::new("client_device_id", "min_length")); }
|
|
if self.clientDeviceId.len() > 128 { return Err(ValidationError::new("client_device_id", "max_length")); }
|
|
if self.deviceKeyId.is_empty() { return Err(ValidationError::new("device_key_id", "required")); }
|
|
if !self.deviceKeyId.is_empty() && self.deviceKeyId.len() < 1 { return Err(ValidationError::new("device_key_id", "min_length")); }
|
|
if self.deviceKeyId.len() > 128 { return Err(ValidationError::new("device_key_id", "max_length")); }
|
|
if self.poolId.is_empty() { return Err(ValidationError::new("pool_id", "required")); }
|
|
if !self.poolId.is_empty() && self.poolId.len() < 1 { return Err(ValidationError::new("pool_id", "min_length")); }
|
|
if self.poolId.len() > 128 { return Err(ValidationError::new("pool_id", "max_length")); }
|
|
if self.idempotencyKey.is_empty() { return Err(ValidationError::new("idempotency_key", "required")); }
|
|
if !self.idempotencyKey.is_empty() && self.idempotencyKey.len() < 1 { return Err(ValidationError::new("idempotency_key", "min_length")); }
|
|
if self.idempotencyKey.len() > 256 { return Err(ValidationError::new("idempotency_key", "max_length")); }
|
|
if let Some(value) = &self.requestedDisplayMode {
|
|
value.validate().map_err(|_| ValidationError::new("requested_display_mode", "invalid_object"))?;
|
|
}
|
|
Ok(())
|
|
}
|
|
pub fn clientDeviceId(&self) -> &String { &self.clientDeviceId }
|
|
pub fn deviceKeyId(&self) -> &String { &self.deviceKeyId }
|
|
pub fn poolId(&self) -> &String { &self.poolId }
|
|
pub fn idempotencyKey(&self) -> &String { &self.idempotencyKey }
|
|
pub fn requestedDisplayMode(&self) -> &Option<DisplayMode> { &self.requestedDisplayMode }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct StableError {
|
|
version: String,
|
|
code: String,
|
|
message: String,
|
|
retryable: bool,
|
|
}
|
|
|
|
impl StableError {
|
|
pub fn new(version: String, code: String, message: String, retryable: bool) -> Result<Self, ValidationError> {
|
|
let value = Self { version, code, message, retryable };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.version != "1" { return Err(ValidationError::new("version", "invalid_value")); }
|
|
if self.code.is_empty() { return Err(ValidationError::new("code", "required")); }
|
|
if !self.code.is_empty() && self.code.len() < 1 { return Err(ValidationError::new("code", "min_length")); }
|
|
if self.code.len() > 128 { return Err(ValidationError::new("code", "max_length")); }
|
|
if self.message.is_empty() { return Err(ValidationError::new("message", "required")); }
|
|
if !self.message.is_empty() && self.message.len() < 1 { return Err(ValidationError::new("message", "min_length")); }
|
|
if self.message.len() > 512 { return Err(ValidationError::new("message", "max_length")); }
|
|
Ok(())
|
|
}
|
|
pub fn version(&self) -> &String { &self.version }
|
|
pub fn code(&self) -> &String { &self.code }
|
|
pub fn message(&self) -> &String { &self.message }
|
|
pub fn retryable(&self) -> &bool { &self.retryable }
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct TunnelAdmissionRequest {
|
|
version: String,
|
|
sessionId: String,
|
|
gatewayId: String,
|
|
audience: String,
|
|
grant: String,
|
|
reconnectSequence: i64,
|
|
clientNonce: String,
|
|
deviceSignature: String,
|
|
capabilities: CapabilityProfile,
|
|
}
|
|
|
|
impl TunnelAdmissionRequest {
|
|
pub fn new(version: String, sessionId: String, gatewayId: String, audience: String, grant: String, reconnectSequence: i64, clientNonce: String, deviceSignature: String, capabilities: CapabilityProfile) -> Result<Self, ValidationError> {
|
|
let value = Self { version, sessionId, gatewayId, audience, grant, reconnectSequence, clientNonce, deviceSignature, capabilities };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.version != "1" { return Err(ValidationError::new("version", "invalid_value")); }
|
|
if self.sessionId.is_empty() { return Err(ValidationError::new("session_id", "required")); }
|
|
if !self.sessionId.is_empty() && self.sessionId.len() < 1 { return Err(ValidationError::new("session_id", "min_length")); }
|
|
if self.sessionId.len() > 128 { return Err(ValidationError::new("session_id", "max_length")); }
|
|
if self.gatewayId.is_empty() { return Err(ValidationError::new("gateway_id", "required")); }
|
|
if !self.gatewayId.is_empty() && self.gatewayId.len() < 1 { return Err(ValidationError::new("gateway_id", "min_length")); }
|
|
if self.gatewayId.len() > 128 { return Err(ValidationError::new("gateway_id", "max_length")); }
|
|
if self.audience.is_empty() { return Err(ValidationError::new("audience", "required")); }
|
|
if !self.audience.is_empty() && self.audience.len() < 1 { return Err(ValidationError::new("audience", "min_length")); }
|
|
if self.audience.len() > 256 { return Err(ValidationError::new("audience", "max_length")); }
|
|
if self.grant.is_empty() { return Err(ValidationError::new("grant", "required")); }
|
|
if !self.grant.is_empty() && self.grant.len() < 43 { return Err(ValidationError::new("grant", "min_length")); }
|
|
if self.grant.len() > 256 { return Err(ValidationError::new("grant", "max_length")); }
|
|
if self.reconnectSequence < 0 { return Err(ValidationError::new("reconnect_sequence", "minimum")); }
|
|
if self.clientNonce.is_empty() { return Err(ValidationError::new("client_nonce", "required")); }
|
|
if !self.clientNonce.is_empty() && self.clientNonce.len() < 16 { return Err(ValidationError::new("client_nonce", "min_length")); }
|
|
if self.clientNonce.len() > 128 { return Err(ValidationError::new("client_nonce", "max_length")); }
|
|
if self.deviceSignature.is_empty() { return Err(ValidationError::new("device_signature", "required")); }
|
|
if !self.deviceSignature.is_empty() && self.deviceSignature.len() < 86 { return Err(ValidationError::new("device_signature", "min_length")); }
|
|
if self.deviceSignature.len() > 86 { return Err(ValidationError::new("device_signature", "max_length")); }
|
|
self.capabilities.validate().map_err(|_| ValidationError::new("capabilities", "invalid_object"))?;
|
|
Ok(())
|
|
}
|
|
pub fn version(&self) -> &String { &self.version }
|
|
pub fn sessionId(&self) -> &String { &self.sessionId }
|
|
pub fn gatewayId(&self) -> &String { &self.gatewayId }
|
|
pub fn audience(&self) -> &String { &self.audience }
|
|
pub fn grant(&self) -> &String { &self.grant }
|
|
pub fn reconnectSequence(&self) -> &i64 { &self.reconnectSequence }
|
|
pub fn clientNonce(&self) -> &String { &self.clientNonce }
|
|
pub fn deviceSignature(&self) -> &String { &self.deviceSignature }
|
|
pub fn capabilities(&self) -> &CapabilityProfile { &self.capabilities }
|
|
pub fn device_admission_transcript(&self) -> Vec<u8> {
|
|
let reconnect_sequence = self.reconnectSequence.to_string();
|
|
let client_decode_count = self.capabilities.clientDecode.len().to_string();
|
|
let mut fields = vec![self.sessionId.as_str(), self.gatewayId.as_str(), self.audience.as_str(), self.grant.as_str(), reconnect_sequence.as_str(), self.clientNonce.as_str(), self.capabilities.transport.as_str(), self.capabilities.framing.as_str(), self.capabilities.media.as_str(), self.capabilities.audio.as_str(), self.capabilities.sourceRateControl.as_str(), client_decode_count.as_str()];
|
|
fields.extend(self.capabilities.clientDecode.iter().map(String::as_str));
|
|
let mut transcript = String::from("versevdi/tunnel-admission/v1");
|
|
for field in fields { transcript.push_str(&format!("{}:{}", field.as_bytes().len(), field)); }
|
|
transcript.into_bytes()
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct VersionNegotiation {
|
|
supportedVersions: Vec<String>,
|
|
features: Vec<String>,
|
|
}
|
|
|
|
impl VersionNegotiation {
|
|
pub fn new(supportedVersions: Vec<String>, features: Vec<String>) -> Result<Self, ValidationError> {
|
|
let value = Self { supportedVersions, features };
|
|
value.validate()?;
|
|
Ok(value)
|
|
}
|
|
pub fn validate(&self) -> Result<(), ValidationError> {
|
|
if self.supportedVersions.len() < 1 { return Err(ValidationError::new("supported_versions", "min_items")); }
|
|
if self.supportedVersions.len() > 3 { return Err(ValidationError::new("supported_versions", "max_items")); }
|
|
for item in self.supportedVersions.iter() { if item.as_bytes().len() > 16 { return Err(ValidationError::new("supported_versions", "max_item_length")); } }
|
|
if self.features.len() > 64 { return Err(ValidationError::new("features", "max_items")); }
|
|
for item in self.features.iter() { if item.as_bytes().len() > 64 { return Err(ValidationError::new("features", "max_item_length")); } }
|
|
Ok(())
|
|
}
|
|
pub fn supportedVersions(&self) -> &Vec<String> { &self.supportedVersions }
|
|
pub fn features(&self) -> &Vec<String> { &self.features }
|
|
}
|
|
|
|
pub fn device_registration_proof_transcript(server_id: &[u8], principal_id: &[u8], device_id: &[u8], challenge: &[u8], expiry_unix_milliseconds: i64) -> Result<Vec<u8>, ValidationError> {
|
|
for (field, value, length) in [("server_id", server_id, 16), ("principal_id", principal_id, 16), ("device_id", device_id, 16), ("challenge", challenge, 32)] {
|
|
if value.len() != length { return Err(ValidationError::new(field, "invalid_length")); }
|
|
}
|
|
if expiry_unix_milliseconds < 0 { return Err(ValidationError::new("expiry_unix_milliseconds", "minimum")); }
|
|
let mut transcript = Vec::with_capacity(112);
|
|
transcript.extend_from_slice(b"versevdi-device-proof-v1");
|
|
transcript.extend_from_slice(server_id);
|
|
transcript.extend_from_slice(principal_id);
|
|
transcript.extend_from_slice(device_id);
|
|
transcript.extend_from_slice(challenge);
|
|
transcript.extend_from_slice(&(expiry_unix_milliseconds as u64).to_be_bytes());
|
|
Ok(transcript)
|
|
}
|
|
|
|
pub fn intersect_capability_profiles(profiles: &[CapabilityProfile]) -> Result<CapabilityProfile, ValidationError> {
|
|
let mut selected = profiles.first().ok_or_else(|| ValidationError::new("capabilities", "no_overlap"))?.clone();
|
|
selected.validate().map_err(|_| ValidationError::new("capabilities", "no_overlap"))?;
|
|
for profile in &profiles[1..] {
|
|
profile.validate().map_err(|_| ValidationError::new("capabilities", "no_overlap"))?;
|
|
if profile.transport != selected.transport || profile.framing != selected.framing || profile.media != selected.media || profile.audio != selected.audio || profile.sourceRateControl != selected.sourceRateControl { return Err(ValidationError::new("capabilities", "no_overlap")); }
|
|
selected.clientDecode.retain(|candidate| profile.clientDecode.contains(candidate));
|
|
if selected.clientDecode.is_empty() { return Err(ValidationError::new("capabilities", "no_overlap")); }
|
|
}
|
|
Ok(selected)
|
|
}
|