Struct cortex::worker::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 copy 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 start_single(
    &self,
    limit: Option<usize>
) -> Result<(), Box<dyn Error + 'static>>

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<File, Box<dyn Error + 'static>>, String, usize, String)

Receive from the source endpoint

fn respond_to_cortex(
    &self,
    file_result: Result<File, Box<dyn Error + 'static>>,
    input_size: usize,
    taskid: &str,
    sink: &Socket
)

Respond to the sink endpoint