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()
}