Struct AlienContext 

pub struct AlienContext { /* private fields */ }

Main context for Alien applications that provides access to:

• Resource bindings (storage, kv, queue, vault, etc.)
• Event handlers (storage events, cron events, queue messages, commands)
• Background tasks (wait_until)
• HTTP server registration

Implementations

impl AlienContext

pub async fn from_env() -> Result<Self>

Creates a new AlienContext from environment variables. This automatically sets up gRPC communication and starts the drain listener.

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

Creates a new AlienContext from provided environment variables. This is useful for testing or when environment variables are not available via std::env.

pub fn new( wait_until_context: Arc<WaitUntilContext>, bindings_provider: Arc<dyn BindingsProviderApi>, ) -> Self

Creates a new AlienContext with custom provider and wait_until context. This is mainly useful for testing or advanced use cases.

pub fn bindings(&self) -> &dyn BindingsProviderApi

Gets the bindings provider for accessing storage, build, and other resources.

pub fn get_bindings(&self) -> Arc<dyn BindingsProviderApi>

Gets the bindings provider as an Arc

pub fn on_storage_event<F, Fut>(&self, resource: &str, handler: F)

where F: Fn(StorageEvent) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<()>> + Send + 'static,

Registers a handler for storage events on the specified bucket/resource.

Example

ctx.on_storage_event("uploads", |event| async move {
    println!("File {} was {}", event.key, event.event_type);
    Ok(())
});

pub fn on_cron_event<F, Fut>(&self, schedule: &str, handler: F)

where F: Fn(CronEvent) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<()>> + Send + 'static,

Registers a handler for cron/scheduled events.

Example

ctx.on_cron_event("daily-cleanup", |event| async move {
    cleanup_old_files().await;
    Ok(())
});

pub fn on_queue_message<F, Fut>(&self, queue: &str, handler: F)

where F: Fn(QueueMessage) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<()>> + Send + 'static,

Registers a handler for queue messages.

Example

ctx.on_queue_message("tasks", |message| async move {
    process_task(&message.payload).await;
    Ok(())
});

pub fn on_command<P, R, F, Fut>(&self, command: &str, handler: F)

where P: DeserializeOwned + Send + 'static, R: Serialize + Send + 'static, F: Fn(P) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<R>> + Send + 'static,

Registers a command handler for ARC remote calls.

Example

ctx.on_command::<GenerateReportParams, ReportResult>("generate-report", |params| async move {
    let report = generate_report(params.start_date, params.end_date).await?;
    Ok(report)
});

pub async fn register_http_server(&self, port: u16) -> Result<()>

Registers the application’s HTTP server port with the runtime. The runtime will forward HTTP requests to this port.

Example

let listener = TcpListener::bind("127.0.0.1:0").await?;
let port = listener.local_addr()?.port();
ctx.register_http_server(port).await?;

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

Enters the main event loop and processes events from the runtime. This blocks until shutdown is signaled.

Call this after registering all event handlers.

Example

ctx.on_storage_event("uploads", handler);
ctx.on_command("process", cmd_handler);
ctx.run().await?;

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

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

Registers a background task that will run even after the main handler returns. The task runs in the application process and is tracked by the runtime for proper shutdown coordination.

pub fn application_id(&self) -> &str

Gets the application ID for this context.

pub async fn get_task_count(&self) -> Result<u32>

Gets the current number of registered wait_until tasks.

pub async fn get_current_function(&self) -> Result<Option<Arc<dyn Function>>>

Gets the current function binding if available.

pub async fn get_current_container(&self) -> Result<Option<Arc<dyn Container>>>

Gets the current container binding if available.

This allows a container to discover its own public and internal URLs. Useful for constructing callback URLs, OAuth redirects, etc.

Example

let ctx = AlienContext::from_env().await?;
if let Some(container) = ctx.get_current_container().await? {
    let public_url = container.get_public_url();
    let callback_url = format!("{}/callback", public_url.unwrap_or(""));
}