packetwire 0.1.0

Bounded deterministic binary packet codec with stream and datagram framing
Documentation
use std::io;
use std::sync::Arc;
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::Duration;

use packetwire::{packet, packet_set};

pub type ExampleError = Box<dyn std::error::Error + Send + Sync>;
pub type ExampleResult<T = ()> = Result<T, ExampleError>;
pub const PACKET_INTERVAL: Duration = Duration::from_millis(500);

#[packet(id = 1)]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct GreetingRequest {
    pub sequence: u32,
    pub name: String,
}

#[packet(id = 2)]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct GreetingResponse {
    pub sequence: u32,
    pub message: String,
}

#[packet(id = 3)]
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct StreamEnd;

#[packet_set]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ExamplePacket {
    GreetingRequest(GreetingRequest),
    GreetingResponse(GreetingResponse),
    StreamEnd(StreamEnd),
}

pub fn greeting_request(sequence: u32) -> GreetingRequest {
    GreetingRequest {
        sequence,
        name: "Packetwire".to_owned(),
    }
}

pub fn interrupt_flag() -> ExampleResult<Arc<AtomicBool>> {
    let running = Arc::new(AtomicBool::new(true));
    let signal_flag = Arc::clone(&running);
    ctrlc::set_handler(move || signal_flag.store(false, Ordering::SeqCst))?;
    Ok(running)
}

pub fn greeting_response(request: &GreetingRequest, transport: &str) -> GreetingResponse {
    GreetingResponse {
        sequence: request.sequence,
        message: format!("Hello, {} over {transport}!", request.name),
    }
}

pub fn validate_response(response: &GreetingResponse, expected_sequence: u32) -> ExampleResult {
    if response.sequence == expected_sequence {
        Ok(())
    } else {
        Err(io::Error::new(
            io::ErrorKind::InvalidData,
            format!(
                "received response {}, expected {expected_sequence}",
                response.sequence
            ),
        )
        .into())
    }
}

pub fn unexpected_packet(expected: &str) -> ExampleError {
    io::Error::new(
        io::ErrorKind::InvalidData,
        format!("received an unexpected packet; expected {expected}"),
    )
    .into()
}