Struct Task 

pub struct Task {

    pub task_id: u64,
    pub dispatcher: String,
    pub dispatcher_address: String,
    pub sid: Sid,
    pub metadata: HashMap<String, Wildcard>,
    pub min_classification: String,
    pub fileinfo: FileInfo,
    pub filename: String,
    pub service_name: ServiceName,
    pub service_config: JsonMap,
    pub depth: u32,
    pub max_files: i32,
    pub ttl: i32,
    pub tags: Vec<TagItem>,
    pub temporary_submission_data: Vec<DataItem>,
    pub deep_scan: bool,
    pub ignore_cache: bool,
    pub ignore_recursion_prevention: bool,
    pub ignore_filtering: bool,
    pub priority: i32,
    pub safelist_config: ServiceSafelist,
}

Service Task Model

Fields

task_id: u64

A random ID to differentiate this task

dispatcher: String

Id of the dispatcher that issued this task

dispatcher_address: String

sid: Sid

Submission ID

metadata: HashMap<String, Wildcard>

Metadata associated to the submission

min_classification: String

Minimum classification of the file being scanned

fileinfo: FileInfo

File info block

filename: String

File name

service_name: ServiceName

Service name

service_config: JsonMap

Service specific parameters

depth: u32

File depth relative to initital submitted file

max_files: i32

Maximum number of files that submission can have

ttl: i32

Task TTL

tags: Vec<TagItem>

List of tags

temporary_submission_data: Vec<DataItem>

Temporary submission data

deep_scan: bool

Perform deep scanning

ignore_cache: bool

Whether the service cache should be ignored during the processing of this task

ignore_recursion_prevention: bool

Whether the service should ignore the dynamic recursion prevention or not

ignore_filtering: bool

Should the service filter it’s output?

priority: i32

Priority for processing order

safelist_config: ServiceSafelist

Safelisting configuration (as defined in global configuration)

Implementations

impl Task

pub fn make_key(sid: Sid, service_name: &str, sha: &Sha256) -> String

pub fn key(&self) -> String

pub fn signature(&self) -> TaskSignature

Trait Implementations

impl Clone for Task

fn clone(&self) -> Task

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Task

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Task

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Distribution<Task> for StandardUniform

Available on crate feature rand only.

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

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 PartialEq for Task

fn eq(&self, other: &Task) -> 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 Serialize for Task

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Task

impl StructuralPartialEq for Task