Struct TaskParserEvent 

pub struct TaskParserEvent {
    pub id: Uuid,
    pub account_task: TaskEvent,
    pub timestamp: u64,
    pub metadata: Map<String, Value>,
    pub context: ExecutionMark,
    pub run_id: Uuid,
    pub prefix_request: Uuid,
}

Parser task message model.

Used to create downstream tasks after parsing, or move to the next processing stage. Contains task identity, metadata, execution context, and predecessor request reference.

Fields

id: Uuid

Unique identifier.

account_task: TaskEvent

Associated account task information.

timestamp: u64

Timestamp.

metadata: Map<String, Value>

Metadata (TaskParserEvent.meta => Task.metadata => Context.meta.task_meta => Module.generate).

context: ExecutionMark

Execution context (ExecutionMark).

run_id: Uuid

Run identifier (Run ID).

prefix_request: Uuid

Predecessor request identifier.

Implementations

impl TaskParserEvent

pub fn with_context(self, ctx: ExecutionMark) -> Self

Sets explicit execution context (ExecutionMark) for parser-chain execution.

Typical uses:

• Precisely control which step index target module starts from.
• Combine with stay_current_step to prevent auto-advancing.

pub fn stay_current_step(self) -> Self

Marks this task to stay on the current parser node and avoid auto-advance.

Behavior:

• When parser returns ParserTaskModel and this is set, the chain loops on this step.
• Otherwise, the loop is considered complete and processing continues.

pub fn get_context(&self) -> &ExecutionMark

pub fn with_meta<T>(self, meta: T) -> Self

where T: Serialize,

pub fn add_meta<T>(self, key: impl AsRef<str>, value: T) -> Self

where T: Serialize,

pub fn with_prefix_request(self, prefix: Uuid) -> Self

Overrides chain backtracking pointer (points to predecessor Request.id).

By default this pointer is inherited from Response.prefix_request. For cross-module jumps, you can set it explicitly to change first-failure fallback target.

pub fn start_other_module( response: &Response, module_name: impl AsRef<str>, ) -> Self

pub fn start_other_module_with_ctx( response: &Response, module_name: impl AsRef<str>, ctx: ExecutionMark, ) -> Self

Creates ParserTaskModel for target module with explicit context.

Typical usage:

• Cross-jump to step 0: pass ExecutionMark::default().with_step_idx(0).
• Stay on current step during retry: pass ExecutionMark with stay_current_step=true.

Trait Implementations

impl Clone for TaskParserEvent

fn clone(&self) -> TaskParserEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TaskParserEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for TaskParserEvent

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl EventProcessorTrait<TaskParserEvent, Task> for TaskModelProcessor

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

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

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

fn error_status( &self, input: &TaskParserEvent, err: &Error, ) -> Option<EventEnvelope>

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

impl From<&Response> for TaskParserEvent

fn from(value: &Response) -> Self

Converts to this type from the input type.

impl From<&TaskParserEvent> for ParserTaskModelEvent

fn from(value: &TaskParserEvent) -> Self

Converts to this type from the input type.

impl From<TaskParserEvent> for UnifiedTaskInput

fn from(value: TaskParserEvent) -> Self

Converts to this type from the input type.

impl Identifiable for TaskParserEvent

fn get_id(&self) -> String

fn partition_key(&self) -> String

MQ partition key: decides which partition / stream shard / consumer a message is routed to, used for account affinity (session stickiness + tasks for the same account landing on the same node within the cluster).

impl Offloadable for TaskParserEvent

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 TaskParserEvent

fn get_priority(&self) -> Priority

impl ProcessorTrait<TaskParserEvent, Task> for TaskModelProcessor

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

Processor name.

fn process<'life0, 'async_trait>( &'life0 self, input: TaskParserEvent, 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 TaskParserEvent, _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 TaskParserEvent, 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 TaskParserEvent

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

where __S: Serializer,

Serialize this value into the given Serde serializer.