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 Binding for WaitUntilContext

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.