Enum FactoryMessage 

pub enum FactoryMessage<TKey, TMsg>
where
    TKey: JobKey,
    TMsg: Message,
{
    Dispatch(Job<TKey, TMsg>),
    Finished(usize, TKey),
    DoPings(Instant),
    Calculate,
    WorkerPong(usize, Duration),
    IdentifyStuckWorkers,
    GetQueueDepth(RpcReplyPort<usize>),
    AdjustWorkerPool(usize),
    GetAvailableCapacity(RpcReplyPort<usize>),
    GetNumActiveWorkers(RpcReplyPort<usize>),
    DrainRequests,
    UpdateSettings(UpdateSettingsRequest<TKey, TMsg>),
}

Messages to a factory.

A special note about factory messages in a distributed context!

Factories only support the command FactoryMessage::Dispatch over a cluster configuration as the rest of the message types are internal and only intended for in-host communication. This means if you’re communicating to a factory you would send only a serialized Job which would automatically be converted to a [FactoryMessage::Dispatch(Job)]

Variants

Dispatch(Job<TKey, TMsg>)

Dispatch a new message

Finished(usize, TKey)

A job finished

DoPings(Instant)

Send a ping to the workers of the factory along with tracking the factory’s timing itself

Calculate

Calculate factory properties (loadshedding, concurrency, etc)

WorkerPong(usize, Duration)

A reply to a factory ping supplying the worker id and the time of the ping start

IdentifyStuckWorkers

Trigger a scan for stuck worker detection

GetQueueDepth(RpcReplyPort<usize>)

Retrieve the current queue depth (if in a queueing mode)

AdjustWorkerPool(usize)

Resize the worker pool to the requested size

GetAvailableCapacity(RpcReplyPort<usize>)

Retrieve the available capacity of the worker pool + queue

GetNumActiveWorkers(RpcReplyPort<usize>)

Instantaneous measurement of the number of currently processing requests

DrainRequests

Notify the factory that it’s being drained, and to finish jobs currently in the queue, but discard new work, and once drained exit

NOTE: This is different from draining the actor itself, which allows the pending message queue to flush and then exit. Since the factory holds an internal queue for jobs, it’s possible that the internal state still has work to do while the factory’s input queue is drained. Therefore in order to propertly drain a factory, you should use the DrainRequests version so the internal pending queue is properly flushed.

UpdateSettings(UpdateSettingsRequest<TKey, TMsg>)

Dynamically update the factory’s settings, for those which don’t require strong-type guarantees. This allows, at runtime, changing the

• Worker Count
• Discard Settings
• Lifecycle Hooks
• Statistics collection
• Capacity controller
• Dead-man’s switch
• Discard handler

Trait Implementations

impl<TKey, TMsg> Debug for FactoryMessage<TKey, TMsg>

where TKey: Debug + JobKey, TMsg: Debug + Message,

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

Formats the value using the given formatter.