Struct HydraClient 

pub struct HydraClient<R> { /* private fields */ }

HydraClient connects to the relay server as a producer or consumer, performs handshake, and sends/receives encrypted frames. It maintains an internal memory pool (18 mb) for zero-copy crypto and buffering. The broadcast method allows producers to send encrypted frames to all connected consumers in the same session, while the recv method allows consumers to receive and decrypt frames from the producer.

use hydra_sync::client::{HydraClient, Producer, Consumer};

#[tokio::main]
async fn main() {
    let addr = "127.0.0.1:8000";
    let session_id = [0xFFu8; 64];
    let session_key = [0xAAu8; 32];

    let mut producer = HydraClient::<Producer>::connect(addr, &session_id, session_key).await.unwrap();
    producer.broadcast(b"I luv you >.<").await.unwrap(); // sends to all consumer

    let mut consumer = HydraClient::<Consumer>::connect(addr, &session_id, session_key).await.unwrap();
    consumer.recv().await.unwrap(); // recv whatever next frame on ring buf
}

Implementations

impl HydraClient<Producer>

pub async fn connect<A: ToSocketAddrs>( addr: A, session_id: &[u8; 64], session_key: [u8; 32], ) -> Result<Self>

Connects to the server, performs handshake, and sends a join frame with Role::Producer and session_id.

pub async fn broadcast(&mut self, data: &[u8]) -> Result<()>

Broadcasts the given data as an encrypted frame to all connected consumers (zero-copy) in the same session.

impl HydraClient<Consumer>

pub async fn connect<A: ToSocketAddrs>( addr: A, session_id: &[u8; 64], session_key: [u8; 32], ) -> Result<Self>

Connects to the server, performs handshake, and sends a join frame with the Role::Consumer and session_id.

pub async fn recv(&mut self) -> Result<&[u8]>

Receives the next encrypted frame from the producer, decrypts it, and returns the plaintext data as a byte slice. The returned slice is valid until the next call to recv or broadcast, which may reuse the internal memory pool buffer.

impl<R> HydraClient<R>

pub async fn close(&mut self) -> Result<()>

Closes the client connection gracefully by flushing and shutting down the writer (proper FIN).