Struct TaskEvent 

pub struct TaskEvent {
    pub account: String,
    pub platform: String,
    pub module: Option<Vec<String>>,
    pub priority: Priority,
    pub run_id: Uuid,
}

Base task model.

Defines minimal task identity with account, platform, and module information.

Fields

account: String

Account identifier.

platform: String

Platform identifier.

module: Option<Vec<String>>

Module list (optional; empty means all modules).

priority: Priority

Priority.

run_id: Uuid

Run identifier.

Trait Implementations

impl Clone for TaskEvent

fn clone(&self) -> TaskEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TaskEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TaskEvent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl EventProcessorTrait<TaskEvent, Task> for TaskModelProcessor

fn pre_status(&self, input: &TaskEvent) -> Option<EventEnvelope>

fn finish_status( &self, input: &TaskEvent, output: &Task, ) -> Option<EventEnvelope>

fn working_status(&self, input: &TaskEvent) -> Option<EventEnvelope>

fn error_status( &self, input: &TaskEvent, error: &Error, ) -> Option<EventEnvelope>

fn retry_status( &self, input: &TaskEvent, retry_policy: &RetryPolicy, ) -> Option<EventEnvelope>

impl From<&TaskEvent> for TaskModelEvent

fn from(value: &TaskEvent) -> Self

Converts to this type from the input type.

impl From<TaskEvent> for UnifiedTaskInput

fn from(value: TaskEvent) -> Self

Converts to this type from the input type.

impl Identifiable for TaskEvent

fn partition_key(&self) -> String

Account affinity: tasks for one account land on the same partition (session stickiness + same account on the same node across the cluster).

fn get_id(&self) -> String

impl Offloadable for TaskEvent

fn should_offload(&self, _threshold: usize) -> bool

fn offload<'life0, 'life1, 'async_trait>( &'life0 mut self, _storage: &'life1 Arc<dyn BlobStorage>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn reload<'life0, 'life1, 'async_trait>( &'life0 mut self, _storage: &'life1 Arc<dyn BlobStorage>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl Prioritizable for TaskEvent

fn get_priority(&self) -> Priority

impl ProcessorTrait<TaskEvent, Task> for TaskModelProcessor

fn name(&self) -> &'static str

Processor name.

fn process<'life0, 'async_trait>( &'life0 self, input: TaskEvent, context: ProcessorContext, ) -> Pin<Box<dyn Future<Output = ProcessorResult<Task>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Processes input data.

fn pre_process<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _input: &'life1 TaskEvent, _context: &'life2 ProcessorContext, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Optional pre-processing hook.

fn handle_error<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, input: &'life1 TaskEvent, error: Error, _context: &'life2 ProcessorContext, ) -> Pin<Box<dyn Future<Output = ProcessorResult<Task>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Optional error handling hook.

fn post_process<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _input: &'life1 Input, _output: &'life2 Output, _context: &'life3 ProcessorContext, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Optional post-processing hook.

fn should_process<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _input: &'life1 Input, _context: &'life2 ProcessorContext, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Optional predicate to decide whether this input should be processed.

impl Serialize for TaskEvent

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

where __S: Serializer,

Serialize this value into the given Serde serializer.