Struct DaemonContext 

#[non_exhaustive]
pub struct DaemonContext {
    pub daemon_name: String,
    pub instance_id: Uuid,
    /* private fields */
}

Context available to daemon handlers.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

daemon_name: String

instance_id: Uuid

Implementations

impl DaemonContext

pub fn new( daemon_name: String, instance_id: Uuid, db_pool: PgPool, http_client: CircuitBreakerClient, shutdown_rx: Receiver<bool>, ) -> Self

Create a new daemon context.

pub fn with_kv(self, kv: Arc<dyn KvHandle>) -> Self

Attach a KV store handle. Called by the runtime before handing the context to the handler.

pub fn kv(&self) -> Result<&dyn KvHandle>

Access the KV store.

pub fn with_job_dispatch(self, dispatcher: Arc<dyn JobDispatch>) -> Self

Set job dispatcher.

pub fn with_workflow_dispatch( self, dispatcher: Arc<dyn WorkflowDispatch>, ) -> Self

Set workflow dispatcher.

pub fn with_env_provider(self, provider: Arc<dyn EnvProvider>) -> Self

Set environment provider.

pub fn db(&self) -> ForgeDb

pub fn db_conn(&self) -> DbConn<'_>

Get a DbConn for use in shared helper functions.

pub async fn conn(&self) -> Result<ForgeConn<'static>>

Acquire a connection compatible with sqlx compile-time checked macros.

pub fn http(&self) -> HttpClient

pub fn raw_http(&self) -> &Client

pub fn set_http_timeout(&mut self, timeout: Option<Duration>)

pub async fn dispatch_job<T: Serialize>( &self, job_type: &str, args: T, ) -> Result<Uuid>

Dispatch a background job.

pub async fn dispatch<J: ForgeJob>(&self, args: J::Args) -> Result<Uuid>

Type-safe dispatch: resolves the job name from the type’s ForgeJob impl and serializes the args at the call site.

pub async fn cancel_job( &self, job_id: Uuid, reason: Option<String>, ) -> Result<bool>

Request cancellation for a job.

pub async fn start_workflow<T: Serialize>( &self, workflow_name: &str, input: T, ) -> Result<Uuid>

Start a workflow.

pub async fn start<W: ForgeWorkflow>(&self, input: W::Input) -> Result<Uuid>

Type-safe workflow start.

pub fn is_shutdown_requested(&self) -> bool

Check if shutdown has been requested.

pub async fn shutdown_signal(&self)

Wait for shutdown signal.

Use this in a tokio::select! to handle graceful shutdown:

tokio::select! {
    _ = tokio::time::sleep(Duration::from_secs(60)) => {}
    _ = ctx.shutdown_signal() => break,
}

pub async fn tick(&self, interval: Duration) -> bool

Sleep for interval, waking early if shutdown is requested.

Returns true if the daemon should continue, false if shutdown was requested before or during the sleep. Intended for the main daemon loop:

while ctx.tick(Duration::from_secs(60)).await {
    // do periodic work
}

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

Send heartbeat to indicate daemon is alive.

pub fn trace_id(&self) -> String

Get the trace ID for this daemon execution.

Returns the instance_id as a correlation ID.

pub fn span(&self) -> &Span

Get the parent span for trace propagation.

Use this to create child spans within daemon handlers.

Trait Implementations

impl EnvAccess for DaemonContext

fn env_provider(&self) -> &dyn EnvProvider

fn env(&self, key: &str) -> Option<String>

fn env_or(&self, key: &str, default: &str) -> String

fn env_require(&self, key: &str) -> Result<String>

fn env_parse<T: FromStr>(&self, key: &str) -> Result<T>

where T::Err: Display,

fn env_parse_or<T: FromStr>(&self, key: &str, default: T) -> Result<T>

where T::Err: Display,

Returns the default when unset; errors only if the variable is set but unparseable.

fn env_contains(&self, key: &str) -> bool

impl HandlerContext for DaemonContext

fn db(&self) -> ForgeDb

Database handle with automatic db.query tracing spans.

fn db_conn(&self) -> DbConn<'_>

Unified connection handle for shared helper functions.