aion-worker 0.9.2

Rust remote-worker SDK for executing Aion activities over the gRPC worker protocol.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

//! Rust remote-worker SDK for executing Aion activities over gRPC.
//!
//! The SDK registers typed activity handlers, receives pushed tasks from an
//! `aion-server`, executes them out-of-process, reports results, and sends
//! heartbeats for long-running work.
//!
//! # Example
//!
//! ```no_run
//! # async fn example() -> Result<(), Box<dyn std::error::Error>> {
//! use aion_worker::{ActivityContext, HandlerFuture, Worker, WorkerConfig};
//! use serde::{Deserialize, Serialize};
//!
//! #[derive(Deserialize, Serialize)]
//! struct Input { name: String }
//!
//! #[derive(Serialize)]
//! struct Output { message: String }
//!
//! fn greet(input: Input, _context: &ActivityContext) -> HandlerFuture<'_, Output> {
//!     Box::pin(async move { Ok(Output { message: format!("hello, {}", input.name) }) })
//! }
//!
//! let config = WorkerConfig::builder()
//!     .endpoint("http://127.0.0.1:50051")
//!     .task_queue("default")
//!     .identity("rust-worker-1")
//!     .max_concurrency(4)
//!     .reconnect_initial_backoff(std::time::Duration::from_millis(500))
//!     .reconnect_max_backoff(std::time::Duration::from_secs(5))
//!     .reconnect_max_attempts(10)
//!     .build()?;
//!
//! Worker::builder(config)
//!     .register_activity("examples.greet", greet)?
//!     .build()?
//!     .run()
//!     .await?;
//! # Ok(())
//! # }
//! ```

/// Typed activity registration and failure classification.
pub mod activity;
/// Worker endpoint, identity, transport, and reconnect configuration.
pub mod config;
/// Per-activity execution context, heartbeat, and cancellation handles.
pub mod context;
/// Worker runtime and configuration errors.
pub mod error;
/// Worker-session protocol abstractions and task types.
pub mod protocol;
/// Activity dispatch and task-serving loops.
pub mod runtime;
/// High-level worker builder and run loop.
pub mod worker;

pub use activity::{
    ActivityFailure, ActivityRegistry, Classification, DuplicateActivityType, HandlerFuture,
};
pub use config::{
    ReconnectConfig, TransportCredentials, WorkerConfig, WorkerConfigBuildError,
    WorkerConfigBuilder,
};
pub use context::{ActivityCancellationHandle, ActivityContext, HeartbeatRequest};
pub use error::{MissingActivityHandler, WorkerError};
pub use protocol::{
    ActivityTask, GrpcWorkerSession, PendingActivityReport, ReconnectBackoff,
    RegisteredSessionInfo, UnackedResultTracker, WorkerSession, WorkerSessionEvent,
    WorkerTaskStream, connect_registered_grpc_session, re_report_unacked, reconnect_with_backoff,
    reconnect_with_sleep, register_connected_session, validate_activity_handlers,
};
#[cfg(feature = "liminal-transport")]
pub use runtime::liminal::{
    AgentHarnessConfig, DispatchRequest, DispatchResponse, InterventionReply, InterventionRequest,
    LiminalActivityWorker,
};
pub use runtime::{
    ActivityDispatcher, ActivityEventSender, ControlMessage, ControlReceiver, ControlRegistry,
    DispatchOutcome, NoShutdown, ServeEnd, SessionGuard, SessionHealth, SessionKey,
    TypedActivityDispatcher, decode_payload, encode_payload, harness_error_to_outcome,
    serve_activity_tasks, serve_activity_tasks_until, spawn_agent, spawn_dyn_agent,
};
#[cfg(feature = "liminal-transport")]
pub use runtime::{RedialTiming, serve_with_redial};
pub use worker::{EmptyActivitySet, Worker, WorkerBuilder, run_worker_with_session};