Struct Worker 

pub struct Worker { /* private fields */ }

A worker polls on a certain task queue

Implementations

impl Worker

pub fn new( config: WorkerConfig, sticky_queue_name: Option<String>, client: Arc<dyn WorkerClient>, telem_instance: Option<&TelemetryInstance>, heartbeat_fn: Option<Arc<OnceLock<Box<dyn Fn() -> Option<WorkerHeartbeat> + Send + Sync>>>>, ) -> Self

Creates a new Worker from a WorkerClient instance with real task pollers and optional telemetry.

This is a convenience constructor that logs initialization and delegates to Worker::new_with_pollers() using [TaskPollers::Real].

pub fn replace_client<CT>(&self, new_client: CT)

where CT: Into<AnyClient>,

Replace client. For eager workflow purposes, this new client will now apply to future eager start requests and the older client will not.

pub async fn cached_workflows(&self) -> usize

Returns number of currently cached workflows

Trait Implementations

impl Worker for Worker

fn initiate_shutdown(&self)

Begins the shutdown process, tells pollers they should stop. Is idempotent.

fn validate<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), WorkerValidationError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Validate that the worker can properly connect to server, plus any other validation that needs to be done asynchronously. Lang SDKs should call this function once before calling any others.

fn poll_workflow_activation<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<WorkflowActivation, PollError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Ask the worker for some work, returning a WorkflowActivation. It is then the language SDK’s responsibility to call the appropriate workflow code with the provided inputs. Blocks indefinitely until such work is available or Worker::shutdown is called.

fn poll_activity_task<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<ActivityTask, PollError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Ask the worker for some work, returning an ActivityTask. It is then the language SDK’s responsibility to call the appropriate activity code with the provided inputs. Blocks indefinitely until such work is available or Worker::shutdown is called.

fn poll_nexus_task<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<NexusTask, PollError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Ask the worker for some nexus related work. It is then the language SDK’s responsibility to call the appropriate nexus operation handler code with the provided inputs. Blocks indefinitely until such work is available or Worker::shutdown is called.

fn complete_workflow_activation<'life0, 'async_trait>( &'life0 self, completion: WorkflowActivationCompletion, ) -> Pin<Box<dyn Future<Output = Result<(), CompleteWfError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Tell the worker that a workflow activation has completed. May (and should) be freely called concurrently. The future may take some time to resolve, as fetching more events might be necessary for completion to… complete - thus SDK implementers should make sure they do not serialize completions.

fn complete_activity_task<'life0, 'async_trait>( &'life0 self, completion: ActivityTaskCompletion, ) -> Pin<Box<dyn Future<Output = Result<(), CompleteActivityError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Tell the worker that an activity has finished executing. May (and should) be freely called concurrently.

fn complete_nexus_task<'life0, 'async_trait>( &'life0 self, completion: NexusTaskCompletion, ) -> Pin<Box<dyn Future<Output = Result<(), CompleteNexusError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Tell the worker that a nexus task has completed. May (and should) be freely called concurrently.

fn record_activity_heartbeat(&self, details: ActivityHeartbeat)

Notify the Temporal service that an activity is still alive. Long running activities that take longer than activity_heartbeat_timeout to finish must call this function in order to report progress, otherwise the activity will timeout and a new attempt will be scheduled.

fn request_workflow_eviction(&self, run_id: &str)

Request that a workflow be evicted by its run id. This will generate a workflow activation with the eviction job inside it to be eventually returned by Worker::poll_workflow_activation. If the workflow had any existing outstanding activations, such activations are invalidated and subsequent completions of them will do nothing and log a warning.

fn get_config(&self) -> &WorkerConfig

Return this worker’s config

fn shutdown<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Initiates async shutdown procedure, eventually ceases all polling of the server and shuts down this worker. Worker::poll_workflow_activation and Worker::poll_activity_task should be called until both return a ShutDown error to ensure that all outstanding work is complete. This means that the lang sdk will need to call Worker::complete_workflow_activation and Worker::complete_activity_task for those workflows & activities until they are done. At that point, the lang SDK can end the process, or drop the Worker instance via Worker::finalize_shutdown, which will close the connection and free resources. If you have set WorkerConfig::no_remote_activities, you may skip calling Worker::poll_activity_task.

fn finalize_shutdown<'async_trait>( self, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait,

Completes shutdown and frees all resources. You should avoid simply dropping workers, as this does not allow async tasks to report any panics that may have occurred cleanly.