627 lines
17 KiB
Rust
627 lines
17 KiB
Rust
///! NAC层间路由器
|
||
///!
|
||
///! 管理L0-L1-L2-L3层间的通信和路由
|
||
///!
|
||
///! **NAC四层架构**：
|
||
///! - L0: 基础层（DAG + CBPP共识 + OPN）
|
||
///! - L1: 协议层（NVM + ACC + GNACS + 碎片化）
|
||
///! - L2: 宪法层（宪法收据 + CEE + 合规验证）
|
||
///! - L3: 应用层（业务应用 + UI + API）
|
||
|
||
use crate::primitives::{Address, Hash};
|
||
use std::collections::{HashMap, VecDeque};
|
||
use serde::{Deserialize, Serialize};
|
||
|
||
/// NAC层级
|
||
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
|
||
/// Layer
|
||
pub enum Layer {
|
||
/// L0: 基础层
|
||
L0,
|
||
/// L1: 协议层
|
||
L1,
|
||
/// L2: 宪法层
|
||
L2,
|
||
/// L3: 应用层
|
||
L3,
|
||
}
|
||
|
||
impl Layer {
|
||
/// 获取层级编号
|
||
pub fn level(&self) -> u8 {
|
||
match self {
|
||
Layer::L0 => 0,
|
||
Layer::L1 => 1,
|
||
Layer::L2 => 2,
|
||
Layer::L3 => 3,
|
||
}
|
||
}
|
||
|
||
/// 从层级编号创建
|
||
pub fn from_level(level: u8) -> Option<Self> {
|
||
match level {
|
||
0 => Some(Layer::L0),
|
||
1 => Some(Layer::L1),
|
||
2 => Some(Layer::L2),
|
||
3 => Some(Layer::L3),
|
||
_ => None,
|
||
}
|
||
}
|
||
|
||
/// 是否可以直接通信
|
||
pub fn can_communicate_with(&self, other: &Layer) -> bool {
|
||
// 相邻层可以直接通信
|
||
let diff = (self.level() as i8 - other.level() as i8).abs();
|
||
diff <= 1
|
||
}
|
||
}
|
||
|
||
/// 层间消息类型
|
||
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
|
||
/// LayerMessageType
|
||
pub enum LayerMessageType {
|
||
/// 请求
|
||
Request,
|
||
/// 响应
|
||
Response,
|
||
/// 通知
|
||
Notification,
|
||
/// 事件
|
||
Event,
|
||
}
|
||
|
||
/// 层间消息
|
||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||
/// LayerMessage
|
||
pub struct LayerMessage {
|
||
/// 消息ID
|
||
pub message_id: Hash,
|
||
/// 消息类型
|
||
pub message_type: LayerMessageType,
|
||
/// 源层
|
||
pub source_layer: Layer,
|
||
/// 目标层
|
||
pub target_layer: Layer,
|
||
/// 发送者地址
|
||
pub sender: Address,
|
||
/// 接收者地址（None表示广播）
|
||
pub receiver: Option<Address>,
|
||
/// 消息负载
|
||
pub payload: Vec<u8>,
|
||
/// 时间戳
|
||
pub timestamp: u64,
|
||
/// 优先级（0-255，数字越大优先级越高）
|
||
pub priority: u8,
|
||
/// 路由路径（经过的层）
|
||
pub route_path: Vec<Layer>,
|
||
}
|
||
|
||
impl LayerMessage {
|
||
/// 创建新的层间消息
|
||
pub fn new(
|
||
message_type: LayerMessageType,
|
||
source_layer: Layer,
|
||
target_layer: Layer,
|
||
sender: Address,
|
||
receiver: Option<Address>,
|
||
payload: Vec<u8>,
|
||
timestamp: u64,
|
||
priority: u8,
|
||
) -> Self {
|
||
// 计算消息ID
|
||
let mut data = Vec::new();
|
||
data.push(source_layer.level());
|
||
data.push(target_layer.level());
|
||
data.extend_from_slice(sender.as_bytes());
|
||
if let Some(ref r) = receiver {
|
||
data.extend_from_slice(r.as_bytes());
|
||
}
|
||
data.extend_from_slice(&payload);
|
||
data.extend_from_slice(×tamp.to_le_bytes());
|
||
|
||
let message_id = Hash::sha3_384(&data);
|
||
|
||
Self {
|
||
message_id,
|
||
message_type,
|
||
source_layer,
|
||
target_layer,
|
||
sender,
|
||
receiver,
|
||
payload,
|
||
timestamp,
|
||
priority,
|
||
route_path: vec![source_layer],
|
||
}
|
||
}
|
||
|
||
/// 添加路由路径
|
||
pub fn add_to_route(&mut self, layer: Layer) {
|
||
self.route_path.push(layer);
|
||
}
|
||
|
||
/// 是否到达目标层
|
||
pub fn has_reached_target(&self) -> bool {
|
||
self.route_path.last() == Some(&self.target_layer)
|
||
}
|
||
}
|
||
|
||
/// 层间路由表
|
||
struct RoutingTable {
|
||
/// 路由规则（source_layer, target_layer） => next_layer
|
||
routes: HashMap<(Layer, Layer), Layer>,
|
||
}
|
||
|
||
impl RoutingTable {
|
||
/// 创建新的路由表
|
||
fn new() -> Self {
|
||
let mut routes = HashMap::new();
|
||
|
||
// 初始化默认路由规则
|
||
// L0 <-> L1 直接通信
|
||
routes.insert((Layer::L0, Layer::L1), Layer::L1);
|
||
routes.insert((Layer::L1, Layer::L0), Layer::L0);
|
||
|
||
// L1 <-> L2 直接通信
|
||
routes.insert((Layer::L1, Layer::L2), Layer::L2);
|
||
routes.insert((Layer::L2, Layer::L1), Layer::L1);
|
||
|
||
// L2 <-> L3 直接通信
|
||
routes.insert((Layer::L2, Layer::L3), Layer::L3);
|
||
routes.insert((Layer::L3, Layer::L2), Layer::L2);
|
||
|
||
// L0 -> L2 经过 L1
|
||
routes.insert((Layer::L0, Layer::L2), Layer::L1);
|
||
|
||
// L0 -> L3 经过 L1
|
||
routes.insert((Layer::L0, Layer::L3), Layer::L1);
|
||
|
||
// L1 -> L3 经过 L2
|
||
routes.insert((Layer::L1, Layer::L3), Layer::L2);
|
||
|
||
// L3 -> L1 经过 L2
|
||
routes.insert((Layer::L3, Layer::L1), Layer::L2);
|
||
|
||
// L3 -> L0 经过 L2
|
||
routes.insert((Layer::L3, Layer::L0), Layer::L2);
|
||
|
||
// L2 -> L0 经过 L1
|
||
routes.insert((Layer::L2, Layer::L0), Layer::L1);
|
||
|
||
Self { routes }
|
||
}
|
||
|
||
/// 获取下一跳层级
|
||
fn get_next_hop(&self, current_layer: Layer, target_layer: Layer) -> Option<Layer> {
|
||
if current_layer == target_layer {
|
||
return Some(target_layer);
|
||
}
|
||
|
||
self.routes.get(&(current_layer, target_layer)).copied()
|
||
}
|
||
}
|
||
|
||
/// 层间消息队列
|
||
struct LayerMessageQueue {
|
||
/// 消息队列（按优先级排序）
|
||
queue: VecDeque<LayerMessage>,
|
||
}
|
||
|
||
impl LayerMessageQueue {
|
||
/// 创建新的消息队列
|
||
fn new() -> Self {
|
||
Self {
|
||
queue: VecDeque::new(),
|
||
}
|
||
}
|
||
|
||
/// 添加消息
|
||
fn enqueue(&mut self, message: LayerMessage) {
|
||
// 按优先级插入（优先级高的在前）
|
||
let pos = self.queue
|
||
.iter()
|
||
.position(|m| m.priority < message.priority)
|
||
.unwrap_or(self.queue.len());
|
||
|
||
self.queue.insert(pos, message);
|
||
}
|
||
|
||
/// 取出消息
|
||
fn dequeue(&mut self) -> Option<LayerMessage> {
|
||
self.queue.pop_front()
|
||
}
|
||
|
||
/// 获取队列长度
|
||
fn len(&self) -> usize {
|
||
self.queue.len()
|
||
}
|
||
|
||
/// 是否为空
|
||
#[allow(dead_code)]
|
||
fn is_empty(&self) -> bool {
|
||
self.queue.is_empty()
|
||
}
|
||
}
|
||
|
||
/// 层间路由器
|
||
pub struct LayerRouter {
|
||
/// 当前层级
|
||
current_layer: Layer,
|
||
/// 路由表
|
||
routing_table: RoutingTable,
|
||
/// 待发送消息队列
|
||
outbound_queue: LayerMessageQueue,
|
||
/// 已接收消息队列
|
||
inbound_queue: LayerMessageQueue,
|
||
/// 消息处理器（message_type => handler_id）
|
||
message_handlers: HashMap<LayerMessageType, Vec<String>>,
|
||
/// 统计信息
|
||
stats: RouterStats,
|
||
}
|
||
|
||
impl LayerRouter {
|
||
/// 创建新的层间路由器
|
||
pub fn new(current_layer: Layer) -> Self {
|
||
Self {
|
||
current_layer,
|
||
routing_table: RoutingTable::new(),
|
||
outbound_queue: LayerMessageQueue::new(),
|
||
inbound_queue: LayerMessageQueue::new(),
|
||
message_handlers: HashMap::new(),
|
||
stats: RouterStats::default(),
|
||
}
|
||
}
|
||
|
||
/// 发送消息
|
||
pub fn send_message(
|
||
&mut self,
|
||
message_type: LayerMessageType,
|
||
target_layer: Layer,
|
||
sender: Address,
|
||
receiver: Option<Address>,
|
||
payload: Vec<u8>,
|
||
timestamp: u64,
|
||
priority: u8,
|
||
) -> Result<Hash, String> {
|
||
// 创建消息
|
||
let message = LayerMessage::new(
|
||
message_type,
|
||
self.current_layer,
|
||
target_layer,
|
||
sender,
|
||
receiver,
|
||
payload,
|
||
timestamp,
|
||
priority,
|
||
);
|
||
|
||
let message_id = message.message_id.clone();
|
||
|
||
// 加入发送队列
|
||
self.outbound_queue.enqueue(message);
|
||
self.stats.messages_sent += 1;
|
||
|
||
Ok(message_id)
|
||
}
|
||
|
||
/// 接收消息
|
||
pub fn receive_message(&mut self, mut message: LayerMessage) -> Result<(), String> {
|
||
// 验证消息是否应该到达当前层
|
||
let next_hop = self.routing_table
|
||
.get_next_hop(
|
||
*message.route_path.last().unwrap(),
|
||
message.target_layer,
|
||
)
|
||
.ok_or("No route found")?;
|
||
|
||
if next_hop != self.current_layer {
|
||
return Err(format!(
|
||
"Message should be routed to {:?}, not {:?}",
|
||
next_hop, self.current_layer
|
||
));
|
||
}
|
||
|
||
// 添加到路由路径
|
||
message.add_to_route(self.current_layer);
|
||
|
||
// 如果到达目标层，加入接收队列
|
||
if message.has_reached_target() {
|
||
self.inbound_queue.enqueue(message);
|
||
self.stats.messages_received += 1;
|
||
} else {
|
||
// 否则继续转发
|
||
self.outbound_queue.enqueue(message);
|
||
self.stats.messages_forwarded += 1;
|
||
}
|
||
|
||
Ok(())
|
||
}
|
||
|
||
/// 处理待发送消息
|
||
pub fn process_outbound_messages(&mut self) -> Vec<LayerMessage> {
|
||
let mut processed = Vec::new();
|
||
|
||
while let Some(message) = self.outbound_queue.dequeue() {
|
||
processed.push(message);
|
||
}
|
||
|
||
processed
|
||
}
|
||
|
||
/// 处理已接收消息
|
||
pub fn process_inbound_messages(&mut self) -> Vec<LayerMessage> {
|
||
let mut processed = Vec::new();
|
||
|
||
while let Some(message) = self.inbound_queue.dequeue() {
|
||
processed.push(message);
|
||
}
|
||
|
||
processed
|
||
}
|
||
|
||
/// 注册消息处理器
|
||
pub fn register_handler(&mut self, message_type: LayerMessageType, handler_id: String) {
|
||
self.message_handlers
|
||
.entry(message_type)
|
||
.or_insert_with(Vec::new)
|
||
.push(handler_id);
|
||
}
|
||
|
||
/// 获取消息处理器
|
||
pub fn get_handlers(&self, message_type: &LayerMessageType) -> Option<&Vec<String>> {
|
||
self.message_handlers.get(message_type)
|
||
}
|
||
|
||
/// 获取统计信息
|
||
pub fn get_stats(&self) -> &RouterStats {
|
||
&self.stats
|
||
}
|
||
|
||
/// 获取待发送消息数量
|
||
pub fn outbound_count(&self) -> usize {
|
||
self.outbound_queue.len()
|
||
}
|
||
|
||
/// 获取已接收消息数量
|
||
pub fn inbound_count(&self) -> usize {
|
||
self.inbound_queue.len()
|
||
}
|
||
}
|
||
|
||
/// 路由器统计信息
|
||
#[derive(Debug, Clone, Default)]
|
||
/// RouterStats
|
||
pub struct RouterStats {
|
||
/// 已发送消息数
|
||
pub messages_sent: u64,
|
||
/// 已接收消息数
|
||
pub messages_received: u64,
|
||
/// 已转发消息数
|
||
pub messages_forwarded: u64,
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn test_layer_level() {
|
||
assert_eq!(Layer::L0.level(), 0);
|
||
assert_eq!(Layer::L1.level(), 1);
|
||
assert_eq!(Layer::L2.level(), 2);
|
||
assert_eq!(Layer::L3.level(), 3);
|
||
}
|
||
|
||
#[test]
|
||
fn test_layer_from_level() {
|
||
assert_eq!(Layer::from_level(0), Some(Layer::L0));
|
||
assert_eq!(Layer::from_level(1), Some(Layer::L1));
|
||
assert_eq!(Layer::from_level(2), Some(Layer::L2));
|
||
assert_eq!(Layer::from_level(3), Some(Layer::L3));
|
||
assert_eq!(Layer::from_level(4), None);
|
||
}
|
||
|
||
#[test]
|
||
fn test_layer_communication() {
|
||
// 相邻层可以直接通信
|
||
assert!(Layer::L0.can_communicate_with(&Layer::L1));
|
||
assert!(Layer::L1.can_communicate_with(&Layer::L0));
|
||
assert!(Layer::L1.can_communicate_with(&Layer::L2));
|
||
assert!(Layer::L2.can_communicate_with(&Layer::L3));
|
||
|
||
// 非相邻层不能直接通信
|
||
assert!(!Layer::L0.can_communicate_with(&Layer::L2));
|
||
assert!(!Layer::L0.can_communicate_with(&Layer::L3));
|
||
assert!(!Layer::L1.can_communicate_with(&Layer::L3));
|
||
}
|
||
|
||
#[test]
|
||
fn test_layer_message_creation() {
|
||
let sender = Address::from_slice(&[1u8; 32]).unwrap();
|
||
let receiver = Address::from_slice(&[2u8; 32]).unwrap();
|
||
|
||
let message = LayerMessage::new(
|
||
LayerMessageType::Request,
|
||
Layer::L1,
|
||
Layer::L2,
|
||
sender,
|
||
Some(receiver),
|
||
vec![1, 2, 3],
|
||
1000,
|
||
10,
|
||
);
|
||
|
||
assert_eq!(message.source_layer, Layer::L1);
|
||
assert_eq!(message.target_layer, Layer::L2);
|
||
assert_eq!(message.priority, 10);
|
||
assert_eq!(message.route_path, vec![Layer::L1]);
|
||
assert!(!message.has_reached_target());
|
||
}
|
||
|
||
#[test]
|
||
fn test_routing_table() {
|
||
let table = RoutingTable::new();
|
||
|
||
// 直接通信
|
||
assert_eq!(table.get_next_hop(Layer::L0, Layer::L1), Some(Layer::L1));
|
||
assert_eq!(table.get_next_hop(Layer::L1, Layer::L2), Some(Layer::L2));
|
||
|
||
// 间接通信（L0 -> L2 经过 L1）
|
||
assert_eq!(table.get_next_hop(Layer::L0, Layer::L2), Some(Layer::L1));
|
||
|
||
// 间接通信（L0 -> L3 经过 L1）
|
||
assert_eq!(table.get_next_hop(Layer::L0, Layer::L3), Some(Layer::L1));
|
||
}
|
||
|
||
#[test]
|
||
fn test_message_queue() {
|
||
let mut queue = LayerMessageQueue::new();
|
||
let sender = Address::from_slice(&[1u8; 32]).unwrap();
|
||
|
||
// 添加低优先级消息
|
||
let message1 = LayerMessage::new(
|
||
LayerMessageType::Request,
|
||
Layer::L1,
|
||
Layer::L2,
|
||
sender.clone(),
|
||
None,
|
||
vec![1],
|
||
1000,
|
||
5, // 低优先级
|
||
);
|
||
queue.enqueue(message1);
|
||
|
||
// 添加高优先级消息
|
||
let message2 = LayerMessage::new(
|
||
LayerMessageType::Request,
|
||
Layer::L1,
|
||
Layer::L2,
|
||
sender,
|
||
None,
|
||
vec![2],
|
||
1001,
|
||
10, // 高优先级
|
||
);
|
||
queue.enqueue(message2.clone());
|
||
|
||
// 高优先级消息应该先出队
|
||
let dequeued = queue.dequeue().unwrap();
|
||
assert_eq!(dequeued.message_id, message2.message_id);
|
||
}
|
||
|
||
#[test]
|
||
fn test_layer_router_send() {
|
||
let mut router = LayerRouter::new(Layer::L1);
|
||
let sender = Address::from_slice(&[1u8; 32]).unwrap();
|
||
let receiver = Address::from_slice(&[2u8; 32]).unwrap();
|
||
|
||
let result = router.send_message(
|
||
LayerMessageType::Request,
|
||
Layer::L2,
|
||
sender,
|
||
Some(receiver),
|
||
vec![1, 2, 3],
|
||
1000,
|
||
10,
|
||
);
|
||
|
||
assert!(result.is_ok());
|
||
assert_eq!(router.outbound_count(), 1);
|
||
assert_eq!(router.get_stats().messages_sent, 1);
|
||
}
|
||
|
||
#[test]
|
||
fn test_layer_router_receive() {
|
||
let mut router = LayerRouter::new(Layer::L2);
|
||
let sender = Address::from_slice(&[1u8; 32]).unwrap();
|
||
let receiver = Address::from_slice(&[2u8; 32]).unwrap();
|
||
|
||
// 创建从L1发往L2的消息
|
||
let message = LayerMessage::new(
|
||
LayerMessageType::Request,
|
||
Layer::L1,
|
||
Layer::L2,
|
||
sender,
|
||
Some(receiver),
|
||
vec![1, 2, 3],
|
||
1000,
|
||
10,
|
||
);
|
||
|
||
let result = router.receive_message(message);
|
||
assert!(result.is_ok());
|
||
assert_eq!(router.inbound_count(), 1);
|
||
assert_eq!(router.get_stats().messages_received, 1);
|
||
}
|
||
|
||
#[test]
|
||
fn test_layer_router_forward() {
|
||
let mut router = LayerRouter::new(Layer::L1);
|
||
let sender = Address::from_slice(&[1u8; 32]).unwrap();
|
||
let receiver = Address::from_slice(&[2u8; 32]).unwrap();
|
||
|
||
// 创建从L0发往L2的消息（需要经过L1转发）
|
||
let message = LayerMessage::new(
|
||
LayerMessageType::Request,
|
||
Layer::L0,
|
||
Layer::L2,
|
||
sender,
|
||
Some(receiver),
|
||
vec![1, 2, 3],
|
||
1000,
|
||
10,
|
||
);
|
||
|
||
let result = router.receive_message(message);
|
||
assert!(result.is_ok());
|
||
assert_eq!(router.outbound_count(), 1); // 转发到发送队列
|
||
assert_eq!(router.get_stats().messages_forwarded, 1);
|
||
}
|
||
|
||
#[test]
|
||
fn test_message_handler_registration() {
|
||
let mut router = LayerRouter::new(Layer::L1);
|
||
|
||
router.register_handler(LayerMessageType::Request, "handler1".to_string());
|
||
router.register_handler(LayerMessageType::Request, "handler2".to_string());
|
||
|
||
let handlers = router.get_handlers(&LayerMessageType::Request).unwrap();
|
||
assert_eq!(handlers.len(), 2);
|
||
assert!(handlers.contains(&"handler1".to_string()));
|
||
assert!(handlers.contains(&"handler2".to_string()));
|
||
}
|
||
|
||
#[test]
|
||
fn test_process_messages() {
|
||
let mut router = LayerRouter::new(Layer::L1);
|
||
let sender = Address::from_slice(&[1u8; 32]).unwrap();
|
||
let receiver = Address::from_slice(&[2u8; 32]).unwrap();
|
||
|
||
// 发送2条消息
|
||
router.send_message(
|
||
LayerMessageType::Request,
|
||
Layer::L2,
|
||
sender.clone(),
|
||
Some(receiver.clone()),
|
||
vec![1],
|
||
1000,
|
||
10,
|
||
).unwrap();
|
||
|
||
router.send_message(
|
||
LayerMessageType::Request,
|
||
Layer::L2,
|
||
sender,
|
||
Some(receiver),
|
||
vec![2],
|
||
1001,
|
||
5,
|
||
).unwrap();
|
||
|
||
// 处理待发送消息
|
||
let processed = router.process_outbound_messages();
|
||
assert_eq!(processed.len(), 2);
|
||
assert_eq!(router.outbound_count(), 0);
|
||
}
|
||
}
|