Struct Module 

pub struct Module {

    pub config: Arc<ModuleConfig>,
    pub account: AccountInfo,
    pub platform: PlatformInfo,
    pub error_times: u32,
    pub finished: bool,
    pub data_middleware: Vec<String>,
    pub download_middleware: Vec<String>,
    pub module: Arc<dyn ModuleTrait>,
    pub locker: bool,
    pub locker_ttl: u64,
    pub processor: ModuleDagProcessor,
    pub run_id: Uuid,
    pub prefix_request: Uuid,
    pub pending_ctx: Option<ExecutionMark>,
    pub bound_task_meta: Option<Map<String, Value>>,
    pub bound_login_info: Option<LoginInfo>,
}

Runtime module instance bound to account/platform context.

A Module aggregates static module behavior, resolved configuration, middleware bindings, and DAG-runtime metadata.

Fields

config: Arc<ModuleConfig>

Resolved module configuration.

account: AccountInfo

Bound account info (lightweight, no sea-orm dependency).

platform: PlatformInfo

Bound platform info (lightweight, no sea-orm dependency).

error_times: u32

In-memory error counter snapshot.

finished: bool

Completion flag at module level.

data_middleware: Vec<String>

Data middleware names.

download_middleware: Vec<String>

Download middleware names.

module: Arc<dyn ModuleTrait>

Module behavior implementation.

locker: bool

Whether distributed locking is enabled.

locker_ttl: u64

Lock TTL in seconds.

processor: ModuleDagProcessor

Queue-backed DAG processor for node generation and parsing.

run_id: Uuid

Run identifier for cross-stage scoping.

prefix_request: Uuid

Prefix request for fallback tracing.

pending_ctx: Option<ExecutionMark>

Optional execution context for precise node targeting.

bound_task_meta: Option<Map<String, Value>>

Task metadata injected by TaskModuleProcessor.

bound_login_info: Option<LoginInfo>

Login context injected by TaskModuleProcessor.

Implementations

impl Module

pub fn bind_task_context( &mut self, task_meta: Map<String, Value>, login_info: Option<LoginInfo>, )

Binds task metadata and optional login context.

pub fn runtime_task_context(&self) -> (Map<String, Value>, Option<LoginInfo>)

Returns task metadata and login info used by generate.

pub async fn generate( &self, task_meta: Map<String, Value>, login_info: Option<LoginInfo>, ) -> Result<SyncBoxStream<'static, Request>>

Generates request stream for the current chain step.

Delegates to ModuleDagProcessor, then enriches each request with module/account/platform identity, middleware, config payloads, and run markers.

pub async fn add_step(&self)

Builds the merged DAG definition and initializes the ModuleDagProcessor.

Merges dag_definition() (custom graph) with add_step() (linear steps) when both are provided, following ModuleDagOrchestrator::compile_module priority rules.

pub async fn parser( &self, response: Response, config: Option<Arc<ModuleConfig>>, ) -> Result<TaskOutputEvent>

Parses response at the routed DAG node and handles terminal lifecycle hook.

pub fn id(&self) -> String

Returns stable module runtime id in account-platform-module format.

Trait Implementations

impl Clone for Module

fn clone(&self) -> Module

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl EventProcessorTrait<Module, Pin<Box<dyn Stream<Item = Request> + Sync + Send>>> for TaskProcessor

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

fn finish_status( &self, input: &Module, _output: &SyncBoxStream<'static, Request>, ) -> Option<EventEnvelope>

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

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

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

impl From<&Module> for ModuleGenerateEvent

fn from(value: &Module) -> Self

Converts to this type from the input type.

impl ProcessorTrait<Module, Pin<Box<dyn Stream<Item = Request> + Sync + Send>>> for TaskProcessor

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

Processor name.

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

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

Processes input data.

fn post_process<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _input: &'life1 Module, _output: &'life2 SyncBoxStream<'static, Request>, _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 pre_process<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _input: &'life1 Input, _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 Input, _error: Error, _context: &'life2 ProcessorContext, ) -> Pin<Box<dyn Future<Output = ProcessorResult<Output>> + Send + 'async_trait>>

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

Optional error handling 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 Module

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.