use super::handler::RequestHandler;
use super::metadata::MetadataManager;
use crate::cluster::{ClusterController, MemTransport};
use crate::config::BrokerConfig;
use crate::group::GroupCoordinator;
use crate::internals::InternalTopics;
use crate::metrics::Metrics;
use bytes::Bytes;
use std::sync::Arc;
use tokio::io::{AsyncReadExt, AsyncWriteExt, BufReader};
use tokio::net::{TcpListener, TcpStream};
use tokio::sync::Semaphore;
#[derive(Clone)]
pub struct Broker {
pub config: Arc<BrokerConfig>,
pub metadata: Arc<MetadataManager>,
pub groups: Arc<GroupCoordinator>,
pub controller: Arc<ClusterController>,
pub metrics: Arc<Metrics>,
pub raft_transport: Option<MemTransport>,
pub raft_nodes: Vec<u64>,
}
impl Broker {
pub fn new(config: BrokerConfig) -> Self {
let config = Arc::new(config);
let metadata = Arc::new(MetadataManager::new(config.clone()));
let groups = Arc::new(GroupCoordinator::new(metadata.clone()));
let controller = Arc::new(ClusterController::new(config.clone()));
let metrics: Arc<Metrics> = Arc::new(Metrics::global().clone());
Self {
config,
metadata,
groups,
controller,
metrics,
raft_transport: None,
raft_nodes: Vec::new(),
}
}
pub fn with_raft_cluster(mut self, transport: MemTransport, nodes: Vec<u64>) -> Self {
self.raft_transport = Some(transport);
self.raft_nodes = nodes;
self
}
pub async fn run(&self) -> anyhow::Result<()> {
self.metadata.init()?;
let internals = InternalTopics::new(self.metadata.clone());
internals.ensure_created();
self.groups.init();
self.groups.spawn_expiry_cleanup();
if !self.config.single_node {
if let (Some(transport), nodes) = (self.raft_transport.clone(), self.raft_nodes.clone()) {
if !nodes.is_empty() {
self.controller.start_raft(transport, nodes);
}
}
}
let addr = format!("{}:{}", self.config.host, self.config.port);
let listener = TcpListener::bind(&addr).await?;
tracing::info!("rivine Broker 已监听 {addr} (broker_id={})", self.config.broker_id);
let semaphore = Arc::new(Semaphore::new(1024));
let metadata = self.metadata.clone();
let groups = self.groups.clone();
let metrics = self.metrics.clone();
loop {
let (socket, peer) = listener.accept().await?;
tracing::debug!("新连接: {peer}");
let _permit = semaphore.clone().acquire_owned().await?;
metrics.active_connections.inc();
let metadata = metadata.clone();
let groups = groups.clone();
let metrics_conn = metrics.clone();
let metrics_dec = metrics.clone();
tokio::spawn(async move {
if let Err(e) = handle_connection(metadata, groups, metrics_conn, socket).await {
tracing::warn!("连接处理结束/出错: {e}");
}
metrics_dec.active_connections.dec();
});
}
}
}
async fn handle_connection(
metadata: Arc<MetadataManager>,
groups: Arc<GroupCoordinator>,
metrics: Arc<Metrics>,
socket: TcpStream,
) -> anyhow::Result<()> {
let (read_half, write_half) = socket.into_split();
let mut reader = BufReader::new(read_half);
let mut writer = write_half;
let handler = RequestHandler::new(metadata, groups, metrics);
let mut buf = Vec::new();
loop {
let mut len_buf = [0u8; 4];
match reader.read_exact(&mut len_buf).await {
Ok(_) => {}
Err(e) if e.kind() == std::io::ErrorKind::UnexpectedEof => {
break Ok(()); }
Err(e) => return Err(e.into()),
}
let body_len = u32::from_be_bytes(len_buf) as usize;
if body_len == 0 || body_len > 100 * 1024 * 1024 {
return Err(anyhow::anyhow!("非法的请求长度 {body_len}"));
}
buf.resize(body_len, 0);
reader.read_exact(&mut buf).await?;
let body = Bytes::copy_from_slice(&buf);
let response = handler.process(body).await;
let Some(response) = response else {
continue;
};
let resp_len = response.len() as u32;
writer.write_all(&resp_len.to_be_bytes()).await?;
writer.write_all(&response).await?;
writer.flush().await?;
}
}