Struct Error 

pub struct Error {
    pub archive_ts: Option<DateTime<Utc>>,
    pub created: DateTime<Utc>,
    pub expiry_ts: Option<DateTime<Utc>>,
    pub response: Response,
    pub sha256: Sha256,
    pub error_type: ErrorTypes,
    pub severity: ErrorSeverity,
}

Error Model used by Error Viewer

Fields

archive_ts: Option<DateTime<Utc>>

Time at which the error was archived

created: DateTime<Utc>

Error creation timestamp

expiry_ts: Option<DateTime<Utc>>

Expiry timestamp

response: Response

Response from the service

sha256: Sha256

SHA256 of file related to service error

error_type: ErrorTypes

Type of error

severity: ErrorSeverity

The severity of an error

Implementations

impl Error

pub fn build_key( &self, service_tool_version: Option<&str>, task: Option<&Task>, ) -> Result<String, Error>

pub fn build_unique_key( &self, service_tool_version: Option<&str>, task: Option<&Task>, ) -> Result<String, Error>

pub fn from_submission(context: &Submission) -> NeedsService

pub fn from_task(context: &Task) -> NeedsMessage

pub fn from_result(context: &Result) -> NeedsMessage

Trait Implementations

impl Described<ElasticMeta> for Error

fn metadata() -> Descriptor<ElasticMeta>

Get self description of this type

impl<'de> Deserialize<'de> for Error

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Distribution<Error> for StandardUniform

Available on crate feature rand only.

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Error

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> Iter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> Map<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Map sampled values to type S

impl Readable for Error

fn set_from_archive(&mut self, _from_archive: bool)

impl Serialize for Error

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.