Struct TaskHubGrpcWorker 

pub struct TaskHubGrpcWorker { /* private fields */ }

Worker that connects to a Durable Task sidecar and processes work items.

The worker opens a streaming gRPC connection to receive orchestrator and activity work items, dispatches them to registered handler functions, and returns results to the sidecar.

Example

use dapr_durabletask::worker::TaskHubGrpcWorker;
use dapr_durabletask::task::OrchestrationContext;

let mut worker = TaskHubGrpcWorker::new("http://localhost:4001");
worker.registry_mut().add_named_orchestrator("my_orch", |ctx: OrchestrationContext| async move {
    let result = ctx.call_activity("greet", "world").await?;
    Ok(result)
});
worker.registry_mut().add_named_activity("greet", |_ctx, input| async move {
    Ok(input)
});

let shutdown = tokio_util::sync::CancellationToken::new();
// worker.start(shutdown).await.unwrap();

Implementations

impl TaskHubGrpcWorker

pub fn new(host_address: &str) -> Self

Create a new worker that will connect to the given sidecar address.

pub fn with_options(host_address: &str, options: WorkerOptions) -> Self

Create a new worker with custom options.

pub fn registry_mut(&mut self) -> &mut Registry

Get a mutable reference to the registry for adding orchestrators and activities.

Panics

Panics if called after the registry has been shared (i.e., after start() has begun processing).

pub async fn start(&self, shutdown: CancellationToken) -> Result<()>

Start the worker. Runs until the cancellation token is triggered or the reconnect policy’s max_attempts is exhausted.

Shutdown behaviour

When the cancellation token is fired:

1. The worker stops reading new work items from the sidecar stream.
2. It waits for all in-flight tasks (orchestrations and activities already dispatched) to complete and send their results to the sidecar before returning.

This guarantees that no already-accepted work item is abandoned at shutdown. Work items still queued inside the sidecar but not yet dispatched to this worker are unaffected — the sidecar will re-dispatch them to the next available worker.