use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct BatchPushItem {
pub payload: Vec<u8>,
pub delay_seconds: u64,
pub message_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct AckItem {
pub message_id: String,
pub receipt_handle: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct Message {
pub message_id: String,
pub payload: Vec<u8>,
pub receipt_handle: String,
pub delivery_count: u32,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct RaftLogEntryWire {
pub term: u64,
pub index: u64,
pub command: Vec<u8>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SnapshotItem {
pub id: String,
pub queue: String,
pub visible_at: u64,
pub payload: Vec<u8>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum Request {
Push {
queue_name: String,
payload: Vec<u8>,
delay_seconds: u64,
message_id: String,
},
PushBatch {
queue_name: String,
items: Vec<BatchPushItem>,
},
Poll {
queue_name: String,
visibility_timeout_sec: u32,
batch_size: u32,
},
Ack {
queue_name: String,
message_id: String,
receipt_handle: String,
},
AckBatch {
queue_name: String,
items: Vec<AckItem>,
},
RaftVote {
term: u64,
candidate_id: String,
last_log_index: u64,
last_log_term: u64,
},
RaftAppend {
term: u64,
leader_id: String,
prev_log_index: u64,
prev_log_term: u64,
entries: Vec<RaftLogEntryWire>,
leader_commit: u64,
},
RaftInstallSnapshot {
term: u64,
leader_id: String,
last_included_index: u64,
last_included_term: u64,
items: Vec<SnapshotItem>,
},
JoinCluster {
peer_addr: String,
},
LeaveCluster {
peer_addr: String,
},
Metrics,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum Response {
Push { message_id: String },
PushBatch { message_ids: Vec<String> },
Poll { messages: Vec<Message> },
Ack { success: bool },
AckBatch { acked_count: u32 },
RaftVote { term: u64, vote_granted: bool },
RaftAppend { term: u64, success: bool },
RaftInstallSnapshot { term: u64, success: bool },
ClusterMembership { success: bool, members: Vec<String> },
Metrics { prometheus_text: String },
Redirect { leader: String },
Error { message: String },
}
pub mod codec {
use super::*;
use std::io;
use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
#[inline(always)]
pub async fn write_message<W: AsyncWrite + Unpin, T: Serialize>(writer: &mut W, msg: &T) -> io::Result<()> {
let bytes = postcard::to_allocvec(msg)
.map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e.to_string()))?;
let len = bytes.len() as u32;
let mut frame = Vec::with_capacity(4 + bytes.len());
frame.extend_from_slice(&len.to_be_bytes());
frame.extend_from_slice(&bytes);
writer.write_all(&frame).await?;
writer.flush().await?;
Ok(())
}
#[inline(always)]
pub async fn read_message<R: AsyncRead + Unpin, T: for<'de> Deserialize<'de>>(reader: &mut R) -> io::Result<T> {
let mut len_buf = [0u8; 4];
reader.read_exact(&mut len_buf).await?;
let len = u32::from_be_bytes(len_buf) as usize;
let mut buf = vec![0u8; len];
reader.read_exact(&mut buf).await?;
postcard::from_bytes(&buf)
.map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e.to_string()))
}
#[inline(always)]
pub async fn read_message_with_buf<R: AsyncRead + Unpin, T: for<'de> Deserialize<'de>>(reader: &mut R, buf: &mut Vec<u8>) -> io::Result<T> {
let mut len_buf = [0u8; 4];
reader.read_exact(&mut len_buf).await?;
let len = u32::from_be_bytes(len_buf) as usize;
buf.resize(len, 0);
reader.read_exact(buf).await?;
postcard::from_bytes(buf)
.map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e.to_string()))
}
}