Crate runtara_protocol

Crate runtara_protocol 

Source
Expand description

Runtara Protocol - QUIC + Protobuf communication layer

This crate provides the wire protocol for communication between:

  • Instances and runtara-core (instance protocol)
  • External clients and runtara-core (management protocol)

§Architecture

┌─────────────────────────────────────────────────────────────┐
│                    runtara-protocol                         │
├─────────────────────────────────────────────────────────────┤
│  RPC Layer: Request/Response + Bidirectional Streaming      │
├─────────────────────────────────────────────────────────────┤
│  Serialization: Protobuf (prost)                            │
├─────────────────────────────────────────────────────────────┤
│  Transport: QUIC (quinn)                                    │
└─────────────────────────────────────────────────────────────┘

§Protocols

§Instance Protocol (instance_proto)

Used by instances to communicate with runtara-core:

  • Registration, checkpointing, sleep/wake
  • Events (started, progress, completed, failed)
  • Signal polling and acknowledgment

§Management Protocol (management_proto)

Used by external clients to manage runtara-core:

  • Health checks
  • Send signals to instances
  • Query instance status
  • List instances

§Usage

§Instance Client (scenarios)

ⓘ
use runtara_protocol::{RuntaraClient, RuntaraClientConfig, instance_proto};

let client = RuntaraClient::localhost()?;
client.connect().await?;

let request = instance_proto::RegisterInstanceRequest {
    instance_id: "my-instance".to_string(),
    tenant_id: "tenant-1".to_string(),
    checkpoint_id: None,
};

let rpc_request = instance_proto::RpcRequest {
    request: Some(instance_proto::rpc_request::Request::RegisterInstance(request)),
};

let response: instance_proto::RpcResponse = client.request(&rpc_request).await?;

§Management Client

ⓘ
use runtara_protocol::{RuntaraClient, management_proto};

let client = RuntaraClient::localhost()?;
client.connect().await?;

let request = management_proto::HealthCheckRequest {};
let rpc_request = management_proto::RpcRequest {
    request: Some(management_proto::rpc_request::Request::HealthCheck(request)),
};

let response: management_proto::RpcResponse = client.request(&rpc_request).await?;

Re-exports§

pub use client::ClientError;
pub use client::RuntaraClient;
pub use client::RuntaraClientConfig;
pub use frame::Frame;
pub use frame::FrameError;
pub use frame::FramedStream;
pub use frame::MessageType;
pub use server::ConnectionHandler;
pub use server::RuntaraServer;
pub use server::RuntaraServerConfig;
pub use server::ServerError;
pub use server::StreamHandler;

Modules§

client
QUIC client helpers for connecting to runtara-core.
environment_proto
frame
Wire format for QUIC stream framing.
instance_proto
management_proto
server
QUIC server helpers for runtara-core.