Struct InitWorker 

pub struct InitWorker {
    pub service: String,
    pub version: f32,
    pub message_size: usize,
    pub source: String,
    pub sink: String,
    pub backend_address: String,
    pub identity: String,
}

Worker for initializing/importing a new corpus into CorTeX

Fields

service: String

name of the service (“init”)

version: f32

version, as usual

message_size: usize

message size, as usual

source: String

full URL (including port) to task source/dispatcher

sink: String

full URL (including port) to task sink/receiver

backend_address: String

address to the Task store backend (special case, only for the init service, third-party workers can’t access the Task store directly)

identity: String

thread-local unique identifier

Trait Implementations

impl Clone for InitWorker

fn clone(&self) -> InitWorker

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InitWorker

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

Formats the value using the given formatter.

impl Default for InitWorker

fn default() -> InitWorker

Returns the “default value” for a type.

impl Worker for InitWorker

fn get_service(&self) -> &str

Name of the service, as registered in CorTeX

fn get_source_address(&self) -> Cow<'_, str>

URL to the CorTeX dispatcher

fn get_sink_address(&self) -> Cow<'_, str>

URL to the CorTeX sink

fn get_identity(&self) -> &str

Gets the uniquely identifying string of this worker instance

fn set_identity(&mut self, identity: String)

Sets a uniquely identifying string for this worker instance

fn message_size(&self) -> usize

Size of chunk for network communication, larger implies less IO, smaller implies less RAM use

fn convert(&self, path_opt: &Path) -> Result<File, Box<dyn Error>>

Core processing method

fn start(&mut self, limit: Option<usize>) -> Result<(), Box<dyn Error>>

sets up the worker process, with as many threads as requested

fn pool_size(&self) -> usize

Simultaneous threads used for one worker each

fn recycle_after_task(&self) -> bool

Whether this worker should retire after the task it just completed, so the supervisor forks a fresh process. Checked after the result is returned to the sink, so retiring loses no work; the worker exits cleanly (the supervisor treats it as a recycle, not a crash). Default: never. A long-lived worker overrides this to bound per-process memory — e.g. retire once RSS crosses a high-water mark — so accumulated allocator/interner state is reclaimed by process replacement without ever failing a paper.

fn stable_identity_suffix(&self) -> Option<String>

An optional stable suffix that replaces the per-process PID in the worker’s ZMQ identity (<host>:<service>:<suffix>). Default None → use the PID, which is globally unique across a fleet of independent processes — REQUIRED in the general case, since two workers sharing an identity collide under the dispatcher’s router_handover (see Worker::start).

fn connect_source(&self, context: &Context) -> Result<Socket, Box<dyn Error>>

(Re)build the DEALER request socket: a fresh socket carrying our identity, dialed at the ventilator, with bounded send/recv timeouts.

fn throttle(&self)

Back off and re-request when the dispatcher has no work for us. Keeps an idle worker from busy-spinning on the ventilator. Configurable via CORTEX_WORKER_THROTTLE_SECS (default 60) — lower it for fast services or tests where a 60 s nap dominates the tail (once a corpus drains, an idle worker otherwise sleeps a full minute before noticing fresh work).

fn start_single(&self, limit: Option<usize>) -> Result<(), Box<dyn Error>>

main worker loop for a single thread, works in perpetuity or up to a specified limit

fn receive_from_cortex( &self, input_tmpdir: &TempDir, source: &Socket, ) -> Result<Option<(String, usize, String)>, Box<dyn Error>>

Request one task from the ventilator and stream its source archive to input_tmpdir.

fn respond_to_cortex( &self, file_result: Result<File, Box<dyn Error>>, taskid: &str, sink: &Socket, ) -> Result<(), Box<dyn Error>>

Return one task’s result to the sink as [identity, service, taskid, data…] — exactly the envelope the dispatcher’s sink expects (it re-validates the service against the task before accepting, so the frames must be exact).