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>) -> WaitUntilContext

Creates a new WaitUntilContext.

pub async fn from_env( application_id: Option<String>, ) -> Result<WaitUntilContext, AlienError<ErrorData>>

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<WaitUntilContext, AlienError<ErrorData>>

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>, ) -> WaitUntilContext

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<(), AlienError<ErrorData>>

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<(), AlienError<ErrorData>>

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<(), Error>

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, AlienError<ErrorData>>> + Send + 'async_trait>>

where 'life0: 'async_trait, WaitUntilContext: '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, AlienError<ErrorData>>> + Send + 'async_trait>>

where 'life0: 'async_trait, WaitUntilContext: '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, AlienError<ErrorData>>> + Send + 'async_trait>>

where 'life0: 'async_trait, WaitUntilContext: '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<(), AlienError<ErrorData>>> + Send + 'async_trait>>

where 'life0: 'async_trait, WaitUntilContext: 'async_trait,

Notifies the runtime that draining is complete.

impl Binding for WaitUntilContext