Enum ViolationType 

pub enum ViolationType {
    MemoryLimitExceeded {
        used: u64,
        limit: u64,
    },
    ExecutionTimeExceeded {
        elapsed: Duration,
        limit: Duration,
    },
    MessageRateExceeded {
        rate: u32,
        limit: u32,
    },
    UnauthorizedK2K {
        destination: String,
    },
    UnauthorizedMemoryAccess {
        region: String,
        requested: AccessLevel,
    },
    CheckpointNotAllowed,
    MigrationNotAllowed,
    SpawnNotAllowed,
    HostAccessNotAllowed,
}

Sandbox violation type.

Variants

MemoryLimitExceeded

Memory limit exceeded

Fields

used: u64

Amount of memory used in bytes

limit: u64

Maximum allowed memory in bytes

ExecutionTimeExceeded

Execution time exceeded

Fields

elapsed: Duration

Elapsed execution time

limit: Duration

Maximum allowed execution time

MessageRateExceeded

Message rate exceeded

Fields

rate: u32

Current message rate per second

limit: u32

Maximum allowed rate per second

UnauthorizedK2K

Unauthorized K2K destination

Fields

destination: String

The destination kernel that was blocked

UnauthorizedMemoryAccess

Unauthorized memory access

Fields

region: String

The memory region that was accessed

requested: AccessLevel

The access level that was requested

CheckpointNotAllowed

Checkpoint not allowed

MigrationNotAllowed

Migration not allowed

SpawnNotAllowed

Spawn not allowed

HostAccessNotAllowed

Host access not allowed

Trait Implementations

impl Clone for ViolationType

fn clone(&self) -> ViolationType

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ViolationType

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Display for ViolationType

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq for ViolationType

fn eq(&self, other: &ViolationType) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ViolationType

impl StructuralPartialEq for ViolationType