GitHub – currentspace/capn-rs

use capnweb_server::{Server, ServerConfig, RpcTarget};
use capnweb_core::{CapId, RpcError};
use serde_json::{json, Value};
use std::sync::Arc;

#[derive(Debug)]
struct Calculator;

impl RpcTarget for Calculator {
    async fn call(&self, member: &str, args: VecValue>) -> ResultValue, RpcError> {
        match member {
            "add" => {
                let a = args[0].as_f64().unwrap();
                let b = args[1].as_f64().unwrap();
                Ok(json!(a + b))
            }
            _ => Err(RpcError::not_found("method not found")),
        }
    }
}

#[tokio::main]
async fn main() -> Result(), Boxdyn std::error::Error>> {
    let config = ServerConfig::default();
    let server = Server::new(config);

    // Register capabilities
    server.register_capability(CapId::new(1), Arc::new(Calculator));

    // Run server with HTTP batch endpoint
    server.run().await?;
    Ok(())
}

use capnweb_client::{Client, ClientConfig};
use capnweb_core::CapId;
use serde_json::json;

#[tokio::main]
async fn main() -> Result(), Boxdyn std::error::Error>> {
    // Create client configuration
    let config = ClientConfig {
        url: "http://localhost:8080/rpc/batch".to_string(),
        ..Default::default()
    };
    let client = Client::new(config)?;

    // Make RPC calls
    let result = client.call(CapId::new(1), "add", vec![json!(10), json!(20)]).await?;
    println!("Result: {}", result);

    Ok(())
}

use capnweb_client::{Client, ClientConfig};

let config = ClientConfig {
    url: "http://localhost:8080/rpc/batch".to_string(),
    ..Default::default()
};
let client = Client::new(config)?;

// WebSocket transport is implemented and available
// Usage requires creating a WebSocketTransport from an established WebSocket connection
use capnweb_transport::WebSocketTransport;
use tokio_tungstenite::connect_async;

let (ws_stream, _) = connect_async("ws://localhost:8080/ws").await?;
let transport = WebSocketTransport::new(ws_stream);

use capnweb_server::H3Server;

let mut h3_server = H3Server::new(server);
h3_server.listen("0.0.0.0:8443".parse()?).await?;

// Promise pipelining is handled internally by the protocol
// Multiple calls in a batch are automatically optimized
let batch = vec![
    Message::Call { /* ... */ },
    Message::Call { /* ... */ },
];
// The server processes these with dependency resolution

use serde_json::json;

// Build complex JSON structures for RPC calls
let request_data = json!({
    "users": [user1, user2, user3],
    "statistics": {
        "total_count": total,
        "active_count": active,
    },
    "metadata": {
        "generated_at": timestamp,
        "version": version_info,
    },
});

match client.call(cap_id, "method", args).await {
    Ok(result) => println!("Success: {}", result),
    Err(e) => {
        // RpcError contains code, message, and optional data
        println!("Error {}: {}", e.code, e.message);
        if let Some(data) = &e.data {
            println!("Additional data: {}", data);
        }
    }
}

use capnweb_server::ServerConfig;

let config = ServerConfig {
    port: 8080,
    host: "0.0.0.0".to_string(),
    max_batch_size: 100,
};

use tracing::{info, warn, error};
use tracing_subscriber;

// Enable structured logging
tracing_subscriber::fmt()
    .with_max_level(tracing::Level::INFO)
    .json()
    .init();