Services API

// simplified
use horus::prelude::*;

service! {
    /// Look up a robot's current pose by name.
    GetRobotPose {
        request {
            robot_name: String,
        }
        response {
            x: f64,
            y: f64,
            theta: f64,
            timestamp_ns: u64,
        }
    }
}

// simplified
pub fn call(&self, request: S::Request, timeout: Duration) -> ServiceResult<S::Response>

// simplified
let response = client.call(GetPose { frame: "base" }, 100.ms())?;
println!("x={}, y={}", response.x, response.y);

// simplified
pub fn call_resilient(&mut self, request: S::Request, timeout: Duration) -> ServiceResult<S::Response>

// simplified
pub fn call_resilient_with(&mut self, request: S::Request, timeout: Duration, config: RetryConfig) -> ServiceResult<S::Response>

// simplified
use horus::prelude::*;

let config = RetryConfig::new(5, 50_u64.ms())
    .multiplier(3.0)
    .max_backoff(1_u64.secs());

let response = client.call_resilient_with(request, 2_u64.secs(), config)?;

// simplified
pub fn call_optional(&mut self, request: S::Request, timeout: Duration) -> ServiceResult<Option<S::Response>>

// simplified
use horus::prelude::*;

// Create client for the GetRobotPose service
let mut client = ServiceClient::<GetRobotPose>::new()?;

// Blocking call with 1-second timeout
let response = client.call(
    GetRobotPoseRequest { robot_name: "arm_1".into() },
    1_u64.secs(),
)?;
println!("Robot at ({:.2}, {:.2})", response.x, response.y);

// Resilient call — retries on transient failures
let response = client.call_resilient(
    GetRobotPoseRequest { robot_name: "arm_1".into() },
    2_u64.secs(),
)?;

// Optional call — Ok(None) on timeout
match client.call_optional(
    GetRobotPoseRequest { robot_name: "arm_1".into() },
    100_u64.ms(),
)? {
    Some(res) => println!("Pose: ({:.2}, {:.2})", res.x, res.y),
    None => println!("Pose server not responding"),
}

// simplified
pub fn check(&mut self) -> ServiceResult<Option<Res>>

// simplified
pub fn wait(self) -> ServiceResult<Res>

// simplified
pub fn is_expired(&self) -> bool

// simplified
use horus::prelude::*;

service! {
    GetRobotPose {
        request { robot_name: String }
        response { x: f64, y: f64, theta: f64, timestamp_ns: u64 }
    }
}

struct PlannerNode {
    client: AsyncServiceClient<GetRobotPose>,
    pending: Option<PendingServiceCall<GetRobotPoseResponse>>,
}

impl Node for PlannerNode {
    fn name(&self) -> &str { "Planner" }

    fn tick(&mut self) {
        // Send request if none pending
        if self.pending.is_none() {
            self.pending = Some(self.client.call_async(
                GetRobotPoseRequest { robot_name: "arm_0".into() },
                500_u64.ms(),
            ));
        }

        // Check for response (non-blocking)
        if let Some(ref mut call) = self.pending {
            match call.check() {
                Ok(Some(pose)) => {
                    hlog!(info, "Robot at ({:.2}, {:.2})", pose.x, pose.y);
                    self.pending = None;
                }
                Ok(None) => {} // Still waiting
                Err(e) => {
                    hlog!(warn, "Service call failed: {}", e);
                    self.pending = None;
                }
            }
        }
    }
}

// simplified
type RequestHandler<Req, Res> = Box<dyn Fn(Req) -> Result<Res, String> + Send + Sync + 'static>;

// simplified
use horus::prelude::*;
use std::collections::HashMap;

// Build and start server
let poses: HashMap<String, (f64, f64, f64)> = HashMap::from([
    ("arm_1".into(), (1.5, 2.0, 0.0)),
    ("arm_2".into(), (3.0, 1.0, 1.57)),
]);

let server = ServiceServerBuilder::<GetRobotPose>::new()
    .on_request(move |req| {
        match poses.get(&req.robot_name) {
            Some(&(x, y, theta)) => Ok(GetRobotPoseResponse {
                x, y, theta, timestamp_ns: horus::timestamp_now(),
            }),
            None => Err(format!("Unknown robot: {}", req.robot_name)),
        }
    })
    .poll_interval(1_u64.ms())
    .build()?;

// Server runs in background thread until dropped

// simplified
use horus::prelude::*;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};

// Define a key-value store service
service! {
    /// Get or set values in a shared store.
    KeyValueStore {
        request {
            key: String,
            value: Option<String>,  // None = get, Some = set
        }
        response {
            value: Option<String>,
            found: bool,
        }
    }
}

fn main() -> Result<()> {
    let store = Arc::new(Mutex::new(HashMap::<String, String>::new()));
    let store_clone = store.clone();

    // Start server
    let _server = ServiceServerBuilder::<KeyValueStore>::new()
        .on_request(move |req| {
            let mut map = store_clone.lock().unwrap();
            match req.value {
                Some(val) => {
                    map.insert(req.key, val.clone());
                    Ok(KeyValueStoreResponse { value: Some(val), found: true })
                }
                None => {
                    let val = map.get(&req.key).cloned();
                    let found = val.is_some();
                    Ok(KeyValueStoreResponse { value: val, found })
                }
            }
        })
        .build()?;

    // Client: set a value
    let mut client = ServiceClient::<KeyValueStore>::new()?;
    client.call(
        KeyValueStoreRequest { key: "robot_id".into(), value: Some("arm_01".into()) },
        1_u64.secs(),
    )?;

    // Client: get it back
    let res = client.call(
        KeyValueStoreRequest { key: "robot_id".into(), value: None },
        1_u64.secs(),
    )?;
    assert_eq!(res.value, Some("arm_01".into()));
    assert!(res.found);

    Ok(())
}