第 4 部分：实现 Gossipsub 聊天

本部分实现了一个基于 Gossipsub 协议的聊天应用。Gossipsub 是 libp2p 中的一种发布/订阅协议，采用 gossip 算法实现高效的消息广播，适用于需要向多个节点发送消息的场景。通过本示例，你将学习如何使用 Gossipsub 实现实时聊天功能，如何处理用户输入，以及如何进行消息序列化和反序列化。Gossipsub 是构建实时通信应用的重要组件，它提供了高效、可靠的消息广播机制，使得消息能够快速传播到网络中的所有节点。

核心功能和目标：

• 实现基于 Gossipsub 的聊天功能
• 处理用户输入和消息发送
• 实现消息序列化和反序列化
• 构建实时通信应用

在整个项目中的位置和作用：

• 作为第四个实践示例
• 展示如何使用 Gossipsub 协议
• 为后续功能添加实时通信能力
• 实现消息的高效广播

学习该部分的预期收益：

• 掌握 Gossipsub 协议的工作原理
• 学会实现实时聊天功能
• 理解消息序列化和反序列化
• 为构建实时通信应用奠定基础

4.1 创建 chat 项目

在 crates 目录下创建一个新的子项目：

cd crates
cargo new chat

4.2 修改 crates/chat/Cargo.toml 文件

配置聊天项目的依赖项：

[package]
name = "chat"
version.workspace = true
authors.workspace = true
license.workspace = true
edition.workspace = true
publish.workspace = true

[dependencies]
tracing.workspace = true
tracing-subscriber.workspace = true
tokio.workspace = true
anyhow.workspace = true

libp2p = { workspace = true, features = [
  "tcp",        # TCP 传输
  "noise",      # 噪声协议加密
  "yamux",      # 多路复用
  "mdns",       # mDNS 节点发现
  "tokio",      # Tokio 运行时支持
  "ping",       # Ping 协议
  "macros",     # 网络行为宏
  "identify",   # Identify 协议
  "gossipsub",  # Gossipsub 发布/订阅
] }
serde ={ workspace = true, features = ["derive"]}  # 序列化/反序列化
serde_json.workspace = true                        # JSON 序列化
chrono.workspace = true                            # 时间处理

依赖说明：

• gossipsub：提供 Gossipsub 发布/订阅协议实现
• serde：提供序列化/反序列化功能，用于消息的编码和解码
• serde_json：提供 JSON 序列化/反序列化功能
• chrono：提供时间处理功能，用于消息时间戳

4.3 修改 crates/chat/src/main.rs 文件

实现基于 Gossipsub 的聊天应用：

use std::time::Duration;
use tokio::io::AsyncBufReadExt;

use libp2p::{
  PeerId, Swarm, Transport, core::upgrade, futures::StreamExt, gossipsub, identify, identity, mdns,
  noise, swarm, tcp, yamux,
};

#[derive(swarm::NetworkBehaviour)]
#[behaviour(to_swarm = "MyBehaviourEvent")]
struct MyBehavior {
  mdns: mdns::tokio::Behaviour,
  identify: identify::Behaviour,
  gossipsub: gossipsub::Behaviour,
}

// 2. 定义事件枚举
#[derive(Debug)]
enum MyBehaviourEvent {
  Mdns(mdns::Event),
  Identify(identify::Event),
  Gossipsub(gossipsub::Event),
}

impl From<mdns::Event> for MyBehaviourEvent {
  fn from(value: mdns::Event) -> Self {
    MyBehaviourEvent::Mdns(value)
  }
}
impl From<identify::Event> for MyBehaviourEvent {
  fn from(value: identify::Event) -> Self {
    MyBehaviourEvent::Identify(value)
  }
}
impl From<gossipsub::Event> for MyBehaviourEvent {
  fn from(value: gossipsub::Event) -> Self {
    MyBehaviourEvent::Gossipsub(value)
  }
}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct ChatMessage {
  from: String,
  content: String,
  timestamp: u64,
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
  // 初始化日志追踪器，启用ANSI颜色输出
  tracing_subscriber::fmt().with_ansi(true).init();
  // 输出启动信息
  tracing::info!("start......");

  let key = identity::Keypair::generate_ed25519();
  let peer_id = PeerId::from(key.public());
  tracing::info!("Local peer id: {:?}", peer_id);

  // 创建传输层
  let transport = tcp::tokio::Transport::new(tcp::Config::default())
    .upgrade(upgrade::Version::V1)
    .authenticate(noise::Config::new(&key)?)
    .multiplex(yamux::Config::default())
    .timeout(Duration::from_secs(60))
    .boxed();

  // 创建 mDNS
  let mdns = mdns::tokio::Behaviour::new(mdns::Config::default(), peer_id)?;

  let identify = identify::Behaviour::new(identify::Config::new(
    "demo/1.0.0".to_string(),
    key.public(),
  ));

  let mut gossipsub = gossipsub::Behaviour::new(
    gossipsub::MessageAuthenticity::Signed(key.clone()),
    gossipsub::Config::default(),
  )
  .map_err(|e| anyhow::anyhow!("{e}"))?;

  let chat_topic = gossipsub::IdentTopic::new("chat");
  gossipsub.subscribe(&chat_topic)?;

  let behaviour = MyBehavior {
    mdns,
    identify,
    gossipsub,
  };

  let mut swarm = Swarm::new(
    transport,
    behaviour,
    peer_id,
    swarm::Config::with_tokio_executor().with_idle_connection_timeout(Duration::from_secs(60)),
  );

  swarm.listen_on("/ip4/0.0.0.0/tcp/0".parse()?)?;

  let join_msg = ChatMessage {
    from: peer_id.to_string(),
    content: "大家好！我加入了聊天室".to_string(),
    timestamp: std::time::SystemTime::now()
      .duration_since(std::time::UNIX_EPOCH)?
      .as_secs(),
  };

  let msg = serde_json::to_string(&join_msg)?;
  if let Err(e) = swarm
    .behaviour_mut()
    .gossipsub
    .publish(chat_topic.clone(), msg.as_bytes())
  {
    tracing::warn!("发布加入消息失败: {:?}", e);
  }

  tracing::info!("🚀 聊天节点启动，输入消息开始聊天...");

  let stdin = tokio::io::stdin();
  let mut reader = tokio::io::BufReader::new(stdin).lines();

  loop {
    tokio::select! {
      line = reader.next_line() => {
        if let Ok(Some(line)) = line {
          if !line.trim().is_empty() {
            let msg = ChatMessage {
              from: peer_id.to_string(),
              content: line.trim().to_string(),
              timestamp: std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)?
                .as_secs(),
            };
            let msg = serde_json::to_string(&msg)?;
            if let Err(e) = swarm.behaviour_mut().gossipsub.publish(chat_topic.clone(), msg.as_bytes()) {
              tracing::error!("❌ 发布消息失败: {:?}", e);
            }
          }
        }
      }
      event = swarm.select_next_some() => match event {
        swarm::SwarmEvent::NewListenAddr { address, .. } => tracing::info!("👂 监听地址: {address}"),
        swarm::SwarmEvent::Behaviour(event) => match event {
          MyBehaviourEvent::Mdns(event) => match event {
            mdns::Event::Discovered(list) => {
              let local_peer_id = *swarm.local_peer_id();
              for (peer_id, multiaddr) in list {
                // 避免连接到自己
                if peer_id != local_peer_id {
                  tracing::info!("🔍 发现新节点: {}", peer_id);
                  tracing::info!("🔗 节点地址: {}", multiaddr);
                  // 尝试连接，忽略连接错误
                  match swarm.dial(multiaddr) {
                    Ok(_) => tracing::info!("🔗 连接请求已发送: {}", peer_id),
                    Err(e) => tracing::error!("❌ 连接错误: {:?}", e),
                  }
                }
              }
            }
            mdns::Event::Expired(list) => {
              for (peer_id, _multiaddr) in list {
                tracing::warn!("👋 节点离线: {}", peer_id);
              }
            }
          },
          MyBehaviourEvent::Identify(event) => match event {
            identify::Event::Received { peer_id, info, .. } => {
              tracing::info!("📣 节点信息: {peer_id} {info:?}");
            }
            identify::Event::Sent { peer_id, .. } => {
              tracing::info!("📣 发送节点信息: {peer_id}");
            }
            identify::Event::Error { peer_id, error, .. } => {
              tracing::error!("❌ 节点信息错误: {peer_id} {error:?}");
            }
            identify::Event::Pushed { peer_id, info, .. } => {
              tracing::info!("📣 节点信息已推送: {peer_id} {info:?}");
            }
          },
          MyBehaviourEvent::Gossipsub(event) => match event {
            gossipsub::Event::Message {message, ..} => {
              if let Ok(msg) = serde_json::from_slice::<ChatMessage>(&message.data) {
                use chrono::TimeZone;
                let time = chrono::Local.timestamp_opt(msg.timestamp as i64, 0).single().map(|t| t.format("%H:%M:%S").to_string()).unwrap_or_else(|| msg.timestamp.to_string());
                tracing::info!("[{}] {}: {}", time, msg.from, msg.content);
              }
            },
            gossipsub::Event::Subscribed { topic, peer_id, ..} => {
              tracing::info!("✅ 节点: {peer_id} 订阅成功: {topic}");
            },
            _ => {}
          }
        }
        swarm::SwarmEvent::ConnectionEstablished { peer_id, .. } => {
        tracing::info!("✅ 连接成功: {peer_id}")
      }
      swarm::SwarmEvent::ConnectionClosed { peer_id, .. } => {
        tracing::error!("❌ 连接关闭: {peer_id}")
      }
      swarm::SwarmEvent::IncomingConnection { .. } => tracing::info!("🔗 接受连接"),
      swarm::SwarmEvent::IncomingConnectionError { error, .. } => {
        tracing::error!("❌ 接受连接错误: {error:?}")
      }
      swarm::SwarmEvent::OutgoingConnectionError { peer_id, error, .. } => {
        tracing::error!("❌ 连接 {peer_id:?} 错误: {error:?}")
      }
      swarm::SwarmEvent::Dialing { peer_id, .. } => tracing::info!("🔗 正在连接: {peer_id:?}"),
      _ => {}
      }
    }
  }
}

代码详细解析：

1. 消息结构定义：

   • 创建 ChatMessage 结构体，包含发送者、内容和时间戳字段
   • 实现 Debug、Clone、serde::Serialize 和 serde::Deserialize traits
   • 这样可以方便地序列化和反序列化消息

2. 网络行为组合：

   • 创建 MyBehavior 结构体，组合了 mdns::tokio::Behaviour、identify::Behaviour 和 gossipsub::Behaviour
   • 使用 #[derive(swarm::NetworkBehaviour)] 宏自动实现 NetworkBehaviour trait
   • 定义 MyBehaviourEvent 枚举，包含 Mdns、Identify 和 Gossipsub 三个变体

3. Gossipsub 初始化：

   • 创建 gossipsub::Behaviour 实例，配置消息认证方式为 MessageAuthenticity::Signed(key.clone())
   • 使用默认配置，确保消息的真实性和完整性

4. 主题订阅：

   • 创建 "chat" 主题，用于消息广播
   • 订阅该主题，以便接收其他节点发布的消息

5. 加入消息：

   • 节点启动时发送加入聊天室的消息
   • 包含发送者、内容（"大家好！我加入了聊天室"）和时间戳
   • 这样其他节点可以知道有新节点加入

6. 用户输入处理：

   • 使用 tokio::select! 同时处理用户输入和网络事件
   • 读取用户输入的消息
   • 处理输入为空的情况

7. 消息发布：

   • 将用户输入的消息封装为 ChatMessage 结构体
   • 使用 serde_json 将消息序列化为 JSON 字符串
   • 将序列化后的消息发布到 Gossipsub 主题
   • 处理发布失败的情况

8. 消息接收：

   • 接收来自 Gossipsub 的消息
   • 使用 serde_json 将消息反序列化为 ChatMessage 结构体
   • 使用 chrono 库格式化时间戳
   • 显示消息的发送时间、发送者和内容

9. 其他事件处理：

   • 处理 mDNS 事件，包括发现新节点和节点离线
   • 处理 Identify 事件，包括接收和发送身份信息
   • 处理连接事件，包括连接建立和关闭

4.4 Gossipsub 协议工作原理

Gossipsub 是 libp2p 中的一种发布/订阅协议，采用 gossip 算法实现高效的消息广播。其工作原理如下：

1. 主题订阅：节点订阅感兴趣的主题，如 "chat"
2. 消息发布：节点向订阅的主题发布消息
3. 消息传播：消息通过 gossip 算法在网络中传播
   • 每个节点只与少量邻居节点通信
   • 节点将消息 gossip 给邻居节点
   • 邻居节点再将消息 gossip 给它们的邻居节点
4. 消息验证：接收消息的节点验证消息的真实性和完整性
5. 消息传递：验证通过的消息被传递给应用层处理

Gossipsub 的优点是：

• 可扩展性：网络规模增大时，消息传播效率不会显著下降
• 可靠性：即使部分节点离线，消息仍然可以通过其他路径传播
• 安全性：支持消息签名和验证，防止消息篡改
• 灵活性：可以根据网络条件自动调整传播策略

4.5 Gossipsub 协议深入解析

Gossipsub 协议概述： Gossipsub 是 libp2p 中的一种发布/订阅（pub/sub）协议，采用 gossip 算法实现高效的消息广播。它设计用于大规模 P2P 网络，能够在保证消息传递可靠性的同时，保持较低的网络开销。

核心概念：

• 主题（Topic）：消息的分类标识，节点可以订阅感兴趣的主题
• 消息（Message）：要广播的内容，包含主题、数据和元数据
• 对等节点（Peer）：网络中的参与者，通过 gossip 协议交换消息
• 邻居（Peer Set）：每个节点维护的邻居节点集合，用于消息传播
• Gossip 周期：节点定期与邻居交换消息的时间间隔

协议版本：

• Gossipsub v1：初始版本，采用纯 gossip 机制
• Gossipsub v1.1：改进版本，引入 mesh 机制，提高消息传播效率
• Gossipsub v2：最新版本，进一步优化 mesh 机制和消息传播策略

消息传播机制：

1. Mesh 网络：订阅同一主题的节点形成 mesh 网络，直接交换消息
2. Gossip 扩散：节点定期与随机邻居交换消息摘要，补充 mesh 网络的覆盖
3. 消息验证：每个节点验证收到的消息，确保消息的真实性和完整性
4. 消息去重：节点维护消息 ID 集合，避免处理重复消息
5. 退避策略：当网络拥塞时，自动调整 gossip 频率

安全性考虑：

• 消息签名：使用节点私钥对消息进行签名，防止消息篡改
• 消息验证：接收方验证消息签名，确保消息来源的真实性
• 防 DoS 攻击：实现速率限制和消息大小限制，防止 DoS 攻击
• 防 Sybil 攻击：通过身份验证和信誉系统，减少 Sybil 攻击的影响

4.6 消息格式设计

消息结构：

• 发送者：消息的发送者 ID
• 内容：消息的实际内容
• 时间戳：消息发送的时间
• 主题：消息所属的主题
• 消息 ID：消息的唯一标识符
• 签名：消息的数字签名

设计原则：

1. 简洁性：消息格式应简洁，减少网络传输开销
2. 可扩展性：消息格式应支持扩展，便于添加新字段
3. 可读性：消息格式应易于人类阅读和调试
4. 效率：消息序列化和反序列化应高效

序列化格式：

• JSON：可读性好，适合调试和人类阅读
• CBOR：二进制格式，序列化效率高，适合生产环境
• Protocol Buffers：结构化数据序列化，效率高， schema 严格

示例消息格式：

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
struct ChatMessage {
  from: String,      // 发送者 ID
  content: String,   // 消息内容
  timestamp: u64,    // 时间戳
  topic: String,     // 消息主题
  message_id: String, // 消息 ID
  signature: Option<String>, // 消息签名
}

4.7 用户输入处理

异步输入处理：

• 使用 tokio::io：利用 Tokio 的异步 IO 处理用户输入
• ** BufReader**：使用 tokio::io::BufReader 读取用户输入
• select! 宏：使用 tokio::select! 同时处理用户输入和网络事件

最佳实践：

1. 非阻塞输入：使用异步 IO，避免阻塞事件循环
2. 输入验证：验证用户输入，防止恶意输入
3. 命令解析：解析用户输入的命令，支持特殊命令
4. 错误处理：妥善处理输入错误，提供友好的错误提示
5. 历史记录：实现命令历史记录，提高用户体验

示例代码：

let stdin = tokio::io::stdin();
let mut reader = tokio::io::BufReader::new(stdin).lines();

loop {
  tokio::select! {
    line = reader.next_line() => {
      if let Ok(Some(line)) = line {
        // 处理用户输入
        if !line.trim().is_empty() {
          // 发送消息
        }
      }
    }
    event = swarm.select_next_some() => {
      // 处理网络事件
    }
  }
}

4.8 消息序列化优化

序列化格式选择：

• JSON：适合调试和人类阅读，序列化效率较低
• CBOR：二进制格式，序列化效率高，适合生产环境
• Protocol Buffers：结构化数据序列化，效率高， schema 严格
• MessagePack：二进制格式，序列化效率高，支持多种数据类型

优化策略：

1. 选择合适的序列化格式：根据应用场景选择合适的序列化格式
2. 批量序列化：批量处理消息，减少序列化开销
3. 缓存序列化结果：缓存频繁使用的序列化结果
4. 压缩数据：对大型消息进行压缩，减少网络传输开销
5. 避免不必要的序列化：只序列化必要的数据字段

性能对比：

序列化格式	序列化速度	反序列化速度	数据大小	可读性
JSON	中等	中等	较大	高
CBOR	高	高	小	低
Protocol Buffers	高	高	最小	低
MessagePack	高	高	小	低

4.9 聊天功能扩展

功能扩展：

1. 用户认证：实现用户认证和身份管理
2. 消息加密：对聊天消息进行端到端加密
3. 消息历史：存储和检索消息历史
4. 消息通知：实现消息通知机制
5. 消息格式：支持富文本、表情、图片等多种消息格式
6. 用户状态：显示用户在线/离线状态
7. 群组管理：支持创建和管理聊天群组
8. 消息回执：实现消息已读回执

实现建议：

• 模块化设计：将不同功能模块化，便于扩展
• 插件系统：实现插件系统，支持功能扩展
• 配置管理：提供灵活的配置选项，适应不同场景
• API 设计：设计清晰的 API，便于集成和扩展

4.10 大规模网络性能

性能挑战：

• 消息传播延迟：网络规模增大时，消息传播延迟可能增加
• 网络开销：消息广播可能导致网络拥塞
• 内存使用：维护邻居列表和消息缓存需要大量内存
• CPU 开销：消息验证和处理需要大量 CPU 资源

优化策略：

1. 邻居选择：智能选择邻居节点，提高消息传播效率
2. 消息批处理：批量处理消息，减少网络往返
3. 流量控制：实现流量控制机制，避免网络拥塞
4. 缓存优化：优化消息缓存策略，减少内存使用
5. 并行处理：使用并行处理提高消息处理效率

扩展性考虑：

• 分层设计：采用分层设计，适应不同规模的网络
• 动态调整：根据网络规模和负载动态调整参数
• 负载均衡：实现负载均衡机制，分散网络负载
• 故障恢复：实现快速故障恢复机制，提高网络可靠性

实际案例：

• 以太坊：使用 Gossipsub 进行区块和交易的广播
• IPFS：使用 Gossipsub 进行内容发现和公告
• Polkadot：使用 Gossipsub 进行跨链消息传递
• Filecoin：使用 Gossipsub 进行存储证明和交易广播

4.11 运行项目

在多个终端运行相同的程序：

# 在多个终端运行相同程序
cargo run --package chat

运行效果：

1. 节点启动后会自动发现本地网络中的其他节点
2. 每个节点加入聊天室时会发送一条加入消息，通知其他节点
3. 你可以在任何终端输入消息，消息会被广播到所有其他节点
4. 接收到的消息会显示发送时间、发送者和内容
5. 节点离线时会显示离线信息
6. 节点之间会自动交换身份信息，了解彼此的能力和特性
7. 消息通过 Gossipsub 协议高效地传播到网络中的所有节点

示例输出：

🔑 本地节点ID: 12D3KooW...
👂 监听地址: /ip4/127.0.0.1/tcp/51234
🔍 发现新节点: 12D3KooX...
🔗 连接请求已发送: 12D3KooX...
✅ 连接成功: 12D3KooX...
📣 节点信息: 12D3KooX... ...
[14:30:45] 12D3KooX...: 大家好！我加入了聊天室
[14:30:50] 12D3KooW...: 你好！
[14:30:55] 12D3KooX...: 今天天气不错

4.12 测试场景

场景 1：本地网络聊天

• 在同一台机器上启动多个终端，运行聊天节点
• 观察节点之间的自动发现、连接建立和消息广播
• 测试多节点同时发送消息的情况

场景 2：多机器聊天

• 在同一局域网内的不同机器上运行聊天节点
• 观察跨机器的消息广播和接收
• 测试网络延迟对消息传播的影响

场景 3：节点离线测试

• 启动多个节点，待它们相互发现并建立连接后
• 关闭其中一个节点
• 观察其他节点是否能检测到该节点离线，以及消息是否仍能正常传播

场景 4：消息负载测试

• 启动多个节点，连续发送大量消息
• 测试系统的消息处理能力和稳定性
• 观察消息是否会丢失或重复

4.13 常见问题与解决方案

问题1：消息发送失败

• 原因：网络连接问题、Gossipsub 配置错误或消息格式错误
• 解决方案：
  • 检查网络连接是否正常
  • 确保 Gossipsub 配置正确
  • 检查消息格式是否符合要求

问题2：消息接收延迟

• 原因：网络延迟、Gossipsub 传播策略或节点负载过高
• 解决方案：
  • 检查网络连接质量
  • 调整 Gossipsub 传播策略
  • 确保节点资源充足

问题3：消息丢失

• 原因：网络不稳定、节点离线或 Gossipsub 配置不当
• 解决方案：
  • 检查网络连接稳定性
  • 确保节点保持在线状态
  • 调整 Gossipsub 配置，提高消息可靠性

问题4：消息重复

• 原因：Gossipsub 传播机制或消息处理逻辑问题
• 解决方案：
  • 实现消息去重机制
  • 调整 Gossipsub 传播策略
  • 检查消息处理逻辑是否正确