Struct AppNode 

pub struct AppNode<Op> {
    pub app_id: String,
    pub instance_id: String,
    /* private fields */
}

The central node handle used by application code.

Generic over the operation type Op — the application supplies its own operation enum and AppNode handles serialization, loopback broadcast, and error logging consistently across all operation store backends.

Construct via the named constructors rather than directly:

let node = AppNode::<Op>::grpc("http://[::1]:50051".into(), "my-app-id", "my-instance")?;

Fields

app_id: String

instance_id: String

Implementations

impl<Op: Clone + Serialize + Send + 'static> AppNode<Op>

pub async fn local( pool: SqlitePool, app_id: impl Into<String>, instance_id: impl Into<String>, ) -> Result<Self, Error>

Create a local-only AppNode backed by a SQLite store.

Operations are persisted locally and never forwarded to a remote node.

pub async fn grpc_with_local( pool: SqlitePool, grpc_addr: String, app_id: impl Into<String>, instance_id: impl Into<String>, ) -> Result<Self, ConnectError>

Create an AppNode that persists to a local SQLite store and forwards to lores-node via gRPC, using the local row id as an idempotency key.

If gRPC delivery fails the operation is retained locally for a future drain attempt.

pub fn grpc( grpc_addr: String, app_id: impl Into<String>, instance_id: impl Into<String>, ) -> Result<Self, ConnectError>

Create an AppNode connected to an external lores-node via gRPC.

Uses a lazy connection — no network call until the first publish.

pub fn subscribe(&self) -> Receiver<AppNodeOperation<Op>>

Subscribe to operations published through this node (loopback).

pub fn subscribe_errors(&self) -> Receiver<Option<NodeError>>

Watch the current node error state.

The receiver immediately reflects the current value, so callers that subscribe after an error was set will see it right away.

pub fn subscribe_node_events(&self) -> Receiver<NodeEvent>

pub async fn node_info( &self, node_id: impl Into<String>, ) -> Result<NodeInfo, GetNodeError>

Fetch information about a node in the same region.

pub async fn replay(&self) -> Result<(), StoreError>

where Op: for<'de> Deserialize<'de>,

Replay all locally-stored operations, broadcasting each through the event channel.

pub async fn publish(&self, operation: &Op) -> Result<(), StoreError>

Serialize and publish an operation, then broadcast it locally.

pub async fn run(&self)

where Op: for<'de> Deserialize<'de>,

Drive the remote subscription in a loop, broadcasting incoming operations and errors to all subscribers.

Retries on all transient failures with exponential backoff (1 s → 60 s). The backoff resets whenever the error variant changes (e.g. GrpcUnavailable → RegionNotBound). Call it with tokio::spawn from your application’s main.

Trait Implementations

impl<Op> Clone for AppNode<Op>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.