Struct PullWorkerOptions 

pub struct PullWorkerOptions { /* private fields */ }

Configures outbound polling for a Worker.

Pass this to WorkerOptions::pull. The Worker polls its sticky queue and each registered Flow type, runs at most max_concurrent_tasks handlers, and keeps idle_streams_per_queue waiting streams on each queue. An omitted task limit uses the CPU count; an omitted idle stream count uses one. An omitted drain timeout uses 30 seconds.

use std::sync::Arc;
use dex_sdk::{BlobCache, BlobCacheConfig, Client, ClientOptions, PullWorkerOptions,
    Registry, Worker, WorkerOptions};

let cache = Arc::new(BlobCache::open(BlobCacheConfig::new(
    "/tmp/dex-pull-blobs", 64 * 1024 * 1024, 0,
)?)?);
let registry = Registry::new();
let worker = Worker::try_new(registry.clone(), cache.clone(),
    WorkerOptions::new().pull(PullWorkerOptions::new().max_concurrent_tasks(8)))?;
let client = Client::try_new(registry, cache,
    ClientOptions::new())?;
// Run worker.start() on a dedicated thread; call worker.stop() during shutdown.

Implementations

impl PullWorkerOptions

pub fn new() -> Self

Creates pull options with CPU-count concurrency, one idle stream per queue, and a 30-second drain.

The app Worker ID is generated from process identity and eight random base32 characters.

pub fn max_concurrent_tasks(self, value: usize) -> Self

Sets the maximum number of concurrent Step and RPC handlers.

The default is the available CPU count. Zero returns crate::SdkError::FlowDefinition from crate::Worker::try_new. Additional assignments are rejected at capacity.

pub fn reserved_rpc_tasks(self, value: usize) -> Self

Reserves capacity to protect synchronous RPC latency from long-running Steps.

Unset reserves one slot when resolved capacity is at least two, otherwise zero. With the CPU-count default, Steps get one fewer slot than before. Set zero to opt out. With one slot and no explicit reserve, start warns once that RPCs may wait behind Steps. Flows must stay responsive because RPCs share Worker task capacity with Steps. WaitFor and Execute tasks, including local attempts, are declined when total busy handlers reach the resolved task limit minus this reserve. RPCs use the full limit. API-direct and transactional RPCs both use the full limit. Declines reassign without consuming an attempt. If all Workers remain at the Step limit through the dispatch wait, NO_WORKER_AVAILABLE consumes an attempt and follows the Step retry policy. Local attempts wait the local dispatch wait, then fall back according to their policy. Readiness is unaffected. Declines emit a tracing debug event and increment crate::Worker::pull_reserved_rpc_declines. A queue keeps one extra idle stream for 30 seconds after its last reserve decline. The Worker does not open it while all task slots are busy.

value must be less than the task limit after its CPU-count default is resolved. crate::Worker::try_new returns crate::SdkError::FlowDefinition otherwise. Returns these options with the reserve applied.

use dex_sdk::PullWorkerOptions;
let pull = PullWorkerOptions::new().max_concurrent_tasks(8).reserved_rpc_tasks(2);

pub fn idle_streams_per_queue(self, value: usize) -> Self

Sets the number of waiting streams per queue.

The default is one. Zero returns crate::SdkError::FlowDefinition from crate::Worker::try_new. The Worker also retains busy streams until their tasks finish. A queue keeps one additional idle stream after a recent reserve decline. Use at least two for heavy Step backlogs.

pub fn app_worker_id(self, value: impl Into<String>) -> Self

Overrides the process Worker ID used for sticky routing.

Use a new ID after each process restart. It must contain 1–63 ASCII letters, digits, dots, underscores, or hyphens and must differ from every registered Flow type. Invalid values return crate::SdkError::FlowDefinition from crate::Worker::try_new. If omitted, the Worker generates a fresh ID during construction.

pub fn stop_on_permanent_stream_rejection(self, value: bool) -> Self

Stops when a permanent rejection leaves a queue without any registered stream.

Defaults to false, retrying indefinitely. When enabled, crate::Worker::start drains within the configured timeout, cancels remaining handlers, and waits for their return. It returns a service error exposing crate::SdkError::pull_registration_error before or after initial readiness. Calling crate::Worker::stop afterward remains safe.

pub fn stop_drain_timeout(self, value: Duration) -> Self

Bounds graceful drain before active handlers are cancelled.

The default is 30 seconds. Zero returns crate::SdkError::FlowDefinition from crate::Worker::try_new. A busy server-directed Reconnect uses this duration to wait for server EOF after the final frame. During Stop, half-closed streams use the remaining drain deadline. crate::Worker::start waits for cancelled handlers to return before it exits.

Trait Implementations

impl Clone for PullWorkerOptions

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PullWorkerOptions

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

Formats the value using the given formatter.

impl Default for PullWorkerOptions

fn default() -> Self

Returns the “default value” for a type.