Struct WaitUntilContext 

pub struct WaitUntilContext { /* private fields */ }

A context for managing wait_until tasks within an application. This handles local task execution and coordinates with the runtime via gRPC.

Implementations

impl WaitUntilContext

pub fn new(application_id: Option<String>) -> Self

Creates a new WaitUntilContext.

pub async fn from_env(application_id: Option<String>) -> Result<Self>

Creates a new WaitUntilContext and connects to gRPC endpoint from environment variables. This is the recommended way to create a WaitUntilContext in production.

pub async fn from_env_with_vars( application_id: Option<String>, env_vars: &HashMap<String, String>, ) -> Result<Self>

Creates a new WaitUntilContext and connects to gRPC endpoint from provided environment variables.

pub fn new_with_grpc_client( application_id: Option<String>, grpc_client: WaitUntilServiceClient<Channel>, ) -> Self

Creates a new WaitUntilContext with a gRPC client.

pub fn set_grpc_client(&mut self, client: WaitUntilServiceClient<Channel>)

Sets the gRPC client for communicating with the runtime.

pub fn application_id(&self) -> &str

Gets the application ID.

pub async fn start_drain_listener(&self) -> Result<()>

Starts a background task that waits for drain signals from the runtime. This should be called once when the application starts.

impl WaitUntilContext

pub fn wait_until<F, Fut>(&self, task_fn: F) -> Result<()>

where F: FnOnce() -> Fut + Send + 'static, Fut: Future<Output = ()> + Send + 'static,

Registers a new wait_until task that will be executed immediately. The task runs in the application process but is tracked by the runtime.

Trait Implementations

impl Debug for WaitUntilContext

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

Formats the value using the given formatter.

impl WaitUntil for WaitUntilContext

fn wait_for_drain_signal<'life0, 'async_trait>( &'life0 self, timeout_duration: Option<Duration>, ) -> Pin<Box<dyn Future<Output = Result<DrainConfig>> + Send + 'async_trait>>

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

Waits for a drain signal from the runtime. This is a blocking call that returns when the runtime decides it’s time to drain.

fn drain_all<'life0, 'async_trait>( &'life0 self, config: DrainConfig, ) -> Pin<Box<dyn Future<Output = Result<DrainResponse>> + Send + 'async_trait>>

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

Drains all currently registered tasks. This waits for all tasks to complete or timeout.

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

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

Gets the current number of registered tasks.

fn notify_drain_complete<'life0, 'async_trait>( &'life0 self, response: DrainResponse, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Notifies the runtime that draining is complete.

impl Binding for WaitUntilContext