# 创建一个名为 ns1 的命名空间
sudo ip netns add ns1

# 查看系统中所有的命名空间
sudo ip netns list

# 在 ns1 中执行 ip link 命令查看接口状态
sudo ip netns exec ns1 ip link

# 将 ns1 中的回环接口 lo 启动
sudo ip netns exec ns1 ip link set lo up

# 再次查看，可以看到 lo 已经变为 UNKNOWN 或 UP 状态
sudo ip netns exec ns1 ip link

# 删除名为 ns1 的命名空间
sudo ip netns del ns1

# 如果遇到上述情况，请按照以下步骤排查和解决：
# 1. 排查方法
# 执行下面的命令，查看当前防火墙的转发策略：
# 如果输出结果中包含 Chain FORWARD (policy DROP)，说明防火墙正在拦截你的实验流量。
sudo iptables -L FORWARD -n -v

# 2. 解决办法 执行以下命令，将转发策略修改为“允许” (Accept)：
sudo iptables -P FORWARD ACCEPT

# 执行后再次测试连通性即可恢复正常。
# 注意：重启 Docker 服务或宿主机后，该策略可能会被 Docker 重置，需重新执行上述命令。

# 0. 准备工作：创建一个名为 ns1 的命名空间，相当于创建了一个虚拟主机
sudo ip netns add ns1

# 1. 创建一对 Veth Pair 接口 (网线，成对出现，分别插在两个主机上)
# 我们将这对网线的两个接口分别命名为 veth0 和 veth1。
# 此时，这两个接口都默认位于宿主机的网络空间中。
sudo ip link add veth0 type veth peer name veth1

# 2. 将一端移动到命名空间中
# 我们保留 veth0 在宿主机，将 veth1 移动到 ns1 命名空间中。
# 这相当于把网线的一头插进了 ns1 这台“虚拟主机”，veth0 默认插在宿主机。
sudo ip link set veth1 netns ns1

# 3. 配置宿主机一侧（veth0）
# 给宿主机的 veth0 接口配置 IP 地址（例如 10.0.0.1/24）并启动接口。
sudo ip addr add 10.0.0.1/24 dev veth0
sudo ip link set veth0 up

# 4. 配置命名空间一侧（veth1）
# 使用 ip netns exec 进入 ns1，给 veth1 配置同网段的 IP 地址并启动接口。
# 注意：必须同时启动回环接口 lo，否则某些通信可能会受阻。
sudo ip netns exec ns1 ip addr add 10.0.0.2/24 dev veth1
sudo ip netns exec ns1 ip link set veth1 up
sudo ip netns exec ns1 ip link set lo up

# 5. 验证连通性
# 现在链路已经通了。我们在宿主机上 ping 命名空间里的 IP (10.0.0.2)。
# 如果收到回复，说明虚拟网络构建成功。
ping -c 3 10.0.0.2

# 6. 清理环境
# 删除 Veth Pair 的任意一端（如 veth0），另一端也会随之自动删除。
# 或者直接删除命名空间 ns1，内部的 veth1 也会被自动清理。
sudo ip link delete veth0
sudo ip netns del ns1

#!/bin/bash

# ==========================================
# 0. 核心准备：启用内核转发 & 创建虚拟交换机
# ==========================================
# 开启 IP Forwarding，让宿主机具备路由器功能 (处理 Host3 <-> Host1/2 的流量)
sysctl -w net.ipv4.ip_forward=1 > /dev/null

# 创建一个网桥 br0，相当于在宿主机里放了一台“交换机”，并设置它的 ip
# Host1 和 Host2 都会连接到这个交换机上，实现同网段二层互通
ip link add name br0 type bridge
ip addr add 10.0.1.1/24 dev br0
ip link set br0 up


# ==========================================
# 1. 构建 Host1 & Host2 (同网段: 10.0.1.0/24)
# ==========================================
# [Host1]
ip netns add Host1
ip link add veth1 type veth peer name veth1-ns
# 将 veth1 一端插在 br0 (交换机) 上，而不是直接配 IP
ip link set veth1 master br0
ip link set veth1 up
# 将与 veth1 配对的网线另一头 veth-ns 插到 Host1 主机上，并设置 Host1 的 ip
ip link set veth1-ns netns Host1
ip netns exec Host1 ip addr add 10.0.1.2/24 dev veth1-ns
ip netns exec Host1 ip link set veth1-ns up
ip netns exec Host1 ip link set lo up
# 设置 Host1 的网关指向 br0 的地址 (10.0.1.1)
ip netns exec Host1 ip route add default via 10.0.1.1

# [Host2]
ip netns add Host2
ip link add veth2 type veth peer name veth2-ns
# 将 veth2 也插在同一个 br0 (交换机) 上，网关也指向 br0 的地址 (10.0.1.1)
ip link set veth2 master br0
ip link set veth2 up
ip link set veth2-ns netns Host2
ip netns exec Host2 ip addr add 10.0.1.3/24 dev veth2-ns
ip netns exec Host2 ip link set veth2-ns up
ip netns exec Host2 ip link set lo up
ip netns exec Host2 ip route add default via 10.0.1.1


# ==========================================
# 2. 构建 Host3 (独立网段: 10.0.3.0/24)
# ==========================================
# Host3 是另一个独立网段，通过宿主机路由与 Host1/2 通讯
ip netns add Host3
ip link add veth3 type veth peer name veth3-ns
# 宿主机端配置作为网关，地址设置为 10.0.3.1/24
ip link set veth3 up
ip addr add 10.0.3.1/24 dev veth3
# NS 端的配置，以及默认路由的设置
ip link set veth3-ns netns Host3
ip netns exec Host3 ip addr add 10.0.3.2/24 dev veth3-ns
ip netns exec Host3 ip link set veth3-ns up
ip netns exec Host3 ip link set lo up
ip netns exec Host3 ip route add default via 10.0.3.1


# ==========================================
# 3. 构建 Host4 (孤立网段: 10.0.4.0/24)
# ==========================================
# Host4 虽然有物理连接，但我们模拟“没有路由器”的场景
# 方法是：只给它配 IP，但【不给它配置网关 (default route)】
ip netns add Host4
ip link add veth4 type veth peer name veth4-ns
# 宿主机端配置
ip link set veth4 up
ip addr add 10.0.4.1/24 dev veth4
# NS 端配置：注意！这里只有 IP，没有 route add default
# 这意味着 Host4 只能和直连的 10.0.4.1 通话，不知道怎么去其他网段
ip link set veth4-ns netns Host4
ip netns exec Host4 ip addr add 10.0.4.2/24 dev veth4-ns
ip netns exec Host4 ip link set veth4-ns up
ip netns exec Host4 ip link set lo up

echo "网络构建完成。"

# 1. 让 Host1 (10.0.1.2) 去 ping 同网段的 Host2 (10.0.1.3)
sudo ip netns exec Host1 ping -c 3 10.0.1.3

# 2. 预期输出结果：
PING 10.0.1.3 (10.0.1.3) 56(84) bytes of data.
64 bytes from 10.0.1.3: icmp_seq=1 ttl=64 time=0.045 ms
64 bytes from 10.0.1.3: icmp_seq=2 ttl=64 time=0.056 ms
64 bytes from 10.0.1.3: icmp_seq=3 ttl=64 time=0.052 ms

# 3. 结果分析：
# 原理：数据链路层的二层交换。
# 当 Host1 发送数据时，网桥 br0 检测到目标 MAC 地址位于同一链路的另一个端口，直接进行转发。
# 重点观察：ttl=64。
# TTL (Time To Live) 是数据包的生存时间，每经过一个路由器（网关）就会减 1。
# 这里 TTL 保持为初始值 64 没有减少，证明数据包根本没有经过路由层，
# 就像两个人面对面传纸条，没有经过中间人转交，这是一次纯粹的二层直连通信。

# 1. 让 Host1 (10.0.1.2) 去 ping 不同网段的 Host3 (10.0.3.2)
sudo ip netns exec Host1 ping -c 3 10.0.3.2

# 2. 预期输出结果：
PING 10.0.3.2 (10.0.3.2) 56(84) bytes of data.
64 bytes from 10.0.3.2: icmp_seq=1 ttl=63 time=0.067 ms
64 bytes from 10.0.3.2: icmp_seq=2 ttl=63 time=0.071 ms
64 bytes from 10.0.3.2: icmp_seq=3 ttl=63 time=0.069 ms

# 3. 结果分析：
# 原理：网络层的三层路由转发。
# Host1 发现目标 IP 不在本地，将包发给默认网关（宿主机）。
# 宿主机查表后，将包从 br0 接口路由转发到 veth3 接口。
# 重点观察：ttl=63。
# 这里的 TTL 从默认的 64 变成了 63。这减去的 1 就是宿主机作为路由器扣除的“过路费”。
# 只要看到 TTL 减少了，就铁证如山地说明数据包经过了路由器的转发处理。

# 1. 让 Host4 (10.0.4.2) 尝试 ping Host1 (10.0.1.2)
sudo ip netns exec Host4 ping -c 3 10.0.1.2

# 2. 预期输出结果（直接报错）：
# ping: connect: Network is unreachable

# 3. 进一步验证（查看路由表）：
sudo ip netns exec Host4 ip route
# 输出：
10.0.4.0/24 dev veth4-ns proto kernel scope link src 10.0.4.2
# (注意：这里缺少了 default via ... 的默认路由记录)
# 如果执行 sudo ip netns exec Host3 ip route，那么输出时：
# default via 10.0.3.1 dev veth3-ns  [有默认路由]
# 10.0.3.0/24 dev veth3-ns proto kernel scope link src 10.0.3.2


# 4. 结果分析：
# 原理：路由表缺失导致路径不可达。
# 尽管物理连接是通畅的，但 Host4 的路由表中只有自己门口（10.0.4.0/24）的地图。
# 当它想去 10.0.1.2 时，发现既没有直连路由，也没有默认网关指出“出口”在哪里。
# 内核不知道该把数据包交给谁，因此直接在本地拒绝了请求。
# 这证明了在三层网络中，物理连通不等于逻辑连通，正确的路由配置是通信的必要条件。

# 查看当前的命名空间有什么虚拟主机
 sudo ip netns list

# 一键删除所有网络命名空间：
#   - ip netns list：列出当前系统中所有 netns
#   - awk '{print $1}'：取出 netns 名称（每行的第 1 列）
#   - xargs -I {} ip netns delete {}：对每个 netns 名称执行删除
sudo ip netns list | awk '{print $1}' | xargs -I {} sudo ip netns delete {}

# 这里需要注意的是：删除 netns 会导致对应 veth pair 也自动删除？
#   这是因为 veth 是成对出现的虚拟接口（veth pair），一端在宿主机、另一端被移入 netns。
#   只要任意一端所属的 netns 被删除：
#       → netns 内的那端 veth 会被内核销毁
#       → veth 是成对的，因此宿主机的那一端也会随之被一并删除
#   所以：删除 netns = 相关 veth pair 也自动被删除
# 或者使用下面的命令可以查看当前系统中创建的 veth pair (假设所有veth pair命名中都含有 veth)
ip link | grep veth

# 如果有，可以使用以下命令一键删除【删除的是veth命名的】
ip -o link show | grep veth | awk -F': ' '{print $2}' | cut -d'@' -f1 | xargs -r -n1 sudo ip link delete

# 删除 br-swarm 可以用下面的公式
sudo ip link delete br-swarm

# 1. 首先，确保系统中拥有 nc，如果没有使用下列命令安装。
sudo apt install netcat-openbsd 

# 2. 使用 nc 命令监听端口，使用到的参数如下：
# -l: 监听模式 (Listen)
# -v: 显示详细信息 (Verbose)
# -n: 不解析域名 (加快速度)
# -p: 指定端口 (Port)
sudo ip netns exec Host3 nc -lvnp 8888


# 3. 在新的窗口，让Host1 连接 Host3 的 IP (10.0.3.2:8888)
sudo ip netns exec Host1 nc -v 10.0.3.2 8888

# 4. 成功后，Host1 的终端会提示 Connection to 10.0.3.2 8888 port [tcp/*] succeeded!。
# 此时，你在 Host1 的终端输入任何字符并回车，Host3 的终端都会立刻显示出来；反之亦然。
# 这个实验证明了 Host1 和 Host3 之间成功完成了 TCP 三次握手。数据包不仅被宿主机（路由器）
# 正确转发，还被目标主机的操作系统准确地传递给了监听在 8888 端口的应用程序。

# 1. 首先，在宿主机上通过命令行快速创建一个名为 math_server.py 的脚本。
# (直接创建一个名为 math_server.py 的文件，复制以下所有代码并在终端运行)
# ------------------------- 以下为 math_server.py 的内容 ---------------------------
import socket
HOST = '0.0.0.0'
PORT = 9999
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    s.bind((HOST, PORT))
    s.listen()
    print(f"Host3 计算服务监听中: {PORT}...")
    while True:
        conn, addr = s.accept()
        with conn:
            print(f"连接来自: {addr}")
            conn.sendall(b"Welcome! Enter a number:\n")
            while True:
                data = conn.recv(1024)
                if not data: break
                try:
                    input_str = data.decode().strip()
                    if not input_str: continue
                    num = float(input_str)
                    conn.sendall(f"Result: {num}^2 = {num*num}\n".encode())
                except ValueError:
                    conn.sendall(b"Error: Not a number!\n")
# ------------------------- 以上为 math_server.py 的内容 ---------------------------


# 2. 启动服务端：将该脚本运行在 Host3 的网络命名空间中。
# 注意：这会占用当前终端窗口。
sudo ip netns exec Host3 python3 math_server.py

# 3. 在新的窗口，让 Host1 连接 Host3 的 9999 端口进行测试。
sudo ip netns exec Host1 nc 10.0.3.2 9999

# 4. 连接成功后，进行交互测试。
# 此时，你在 Host1 输入 "5" 并回车，Host3 的 Python 程序会计算并返回 "25.0"。
# 输入 "hello" 则会返回错误提示。
# 这个实验展示了网络编程的核心模型。Host1 发送的数据流经过网络传输到达 Host3，
# Host3 的内核将数据交给 Python 进程。Python 进程解析数据，执行 CPU 计算逻辑，
# 再将结果封装并通过网络发回。这正是现代互联网应用（如 Web 服务、数据库服务）工作的基本原型。

# 什么都没做时，使用Host1 ping Host3，延迟大概为 time=0.xx ms
sudo ip netns exec Host1 ping 10.0.3.2

# 例子：给 Host3 增加 100ms 的固定延迟
# 命令语法：tc qdisc add dev [设备名] root netem delay [时长]
sudo ip netns exec Host3 tc qdisc add dev veth3-ns root netem delay 100ms

# 验证：此时从 Host1 ping Host3
# 结果：time=100.xx ms (原本是 0.0x ms)
sudo ip netns exec Host1 ping 10.0.3.2

# 例子：延迟 100ms，上下波动 20ms (即 80ms ~ 120ms 之间随机)
# 命令语法：tc qdisc [add/change] dev [设备名] root netem delay [基础时长] [波动范围]
# 注意：这里用了 change，如果你之前已经 add 过了，修改规则要用 change，或者先 del 再 add。
sudo ip netns exec Host3 tc qdisc change dev veth3-ns root netem delay 100ms 20ms

# 验证：此时从 Host1 ping Host3
# 结果：time=[100±20].xx ms (原本是 0.0x ms)
sudo ip netns exec Host1 ping 10.0.3.2

# 例子：随机丢弃 30% 的数据包 (非常恶劣的网络环境)
# 命令语法：tc qdisc change dev [设别名] root netem loss [百分比]
sudo ip netns exec Host3 tc qdisc change dev veth3-ns root netem loss 30%

# 验证：ping -c 10，你会发现大概只有 7 个包能收到。当然，会有波动，是随机的。
sudo ip netns exec Host1 ping -c 10 10.0.3.2

# 虽然netem也能做简单的限速，但业界通常使用更准确的tbf算法[Token Bucket Filter 令牌桶]。
# 命令语法：tc qdisc change dev [设备名] 
#               root tbf rate [带宽] burst [缓冲区大小] latency [最大延迟]
# rate:    限制的速率 (如 1mbit, 500kbit)
# burst:   桶的大小/缓冲区 
#          【允许瞬间突发的数据量，通常设为 10kb~32kb，太小会导致低速率下发包困难】
# latency: 也就是 limit，当令牌耗尽时，数据包在队列中等待的最长时间。

# 例子：将 Host3 的出口带宽限制在 1Mbit/s (约 125KB/s)
sudo ip netns exec Host3 tc qdisc change dev veth3-ns 
            root tbf rate 1mbit burst 32kbit latency 400ms

# --- 验证方法 ---
# 我们需要让 Host3 发送大量数据给 Host1，看看速度是不是被卡住了。
# 步骤 1: 在 Host1 (接收端) 开启一个空洞，只接收数据不存盘，避免硬盘读写影响测试
# -l: 监听, -p: 端口
sudo ip netns exec Host1 nc -l -p 8888 > /dev/null 

# 步骤 2: 在 Host3 (发送端/被限速端) 用 dd 生成 5MB 数据并通过管道传给 Host1
# 注意：这里必须用 bash -c "..." 把整个命令包起来，
# 否则管道符 "|" 会被宿主机解释，而不是在 Host3 的命名空间内执行。
# 
# if=/dev/zero: Input File，从系统零设备读取无限的空数据
# bs=1M: Block Size，每块大小为 1MB
# count=5: 读 5 次就停止 (即总共生成 5MB 数据)
# | nc ...: 将 dd 生成的数据流，通过管道直接灌入 nc 发送给目标
sudo ip netns exec Host3 
            bash -c "dd if=/dev/zero bs=1M count=5 | nc 10.0.1.2 8888"

# 预期输出：
# dd 命令执行完毕后会打印统计信息，你应该会看到类似下面的结果：
# 5242880 bytes (5.2 MB, 5.0 MiB) copied, 41.xxx s, 127 kB/s
#
# 结果分析：
# 1. 数据量：5MB 数据传输完毕。
# 2. 耗时：约 41 秒 (5MB * 8bit / 1Mbit ≈ 40秒)。
# 3. 速度：127 kB/s。这正好对应 1mbit (1000000 bits / 8 = 125000 bytes ≈ 125KB/s)。
# 证明限速完美生效。

# 核心原理：
# Netem 的乱序机制其实是“部分包不延迟”。
# 我们设定一个基础延迟（比如 100ms），然后设定一定比例的包（比如 50%）为“乱序包”。
# 结果是：50% 的包会被延迟 100ms 发送，而那 50% 的包会“立即”发送。
# 这样一来，后发的“立即包”就会赶在先发的“延迟包”之前到达目的地，形成乱序。

# 命令语法：tc qdisc change dev [设备名] 
#               root netem delay [基础延迟] reorder [乱序比例] [相关性]
# 例子：设基础延迟 100ms，但有 50% 的包会立即发送，
# 相关性50%指：当前这个包是否乱序，很大程度上取决于前一个包的状态
#            如果第一个包运气不好，没有乱序（走了 100ms 延迟通道）。
#            那么第二个包有 50% 的概率会“模仿”前一个包（也不乱序）。
sudo ip netns exec Host3 tc qdisc change 
            dev veth3-ns root netem delay 100ms reorder 50% 50%

# --- 验证方法 ---
# 使用 ping 命令即可验证。
# 因为 ICMP 报文里有序列号 (icmp_seq)。正常情况下 seq 是 1, 2, 3, 4 递增。
# 如果发生乱序，我们会在接收端看到 seq 的打印顺序变乱。
# 注意：Ping 的速度必须够快！默认 Ping 每秒发一次。如果延迟只有 100ms，
#      前一个包早就到了，后一个包还没发，根本无法发生“插队”。
#      所以我们需要用 -i 参数将发包间隔缩短到 5ms (0.005s)，让包在网络上“拥挤”起来。
sudo ip netns exec Host1 ping -c 20 -i 0.005 10.0.3.2

# 预期输出：
# 请仔细观察 icmp_seq 的数值顺序，你会发现它们不再是严格递增的。
#
# PING 10.0.3.2 (10.0.3.2) 56(84) bytes of data.
# 64 bytes from 10.0.3.2: icmp_seq=2 ttl=63 time=0.040 ms   <-- seq=2 先到了！
# 64 bytes from 10.0.3.2: icmp_seq=1 ttl=63 time=100.1 ms   <-- seq=1 后到了 
# 64 bytes from 10.0.3.2: icmp_seq=4 ttl=63 time=0.035 ms   <-- seq=4 插队了
# 64 bytes from 10.0.3.2: icmp_seq=3 ttl=63 time=100.2 ms   <-- seq=3 姗姗来迟
#
# 结果分析：
# 1. 观察 seq：顺序变成了 2 -> 1 -> 4 -> 3。证明包到达顺序乱了。
# 2. 观察 time：乱序包（插队的）延迟极低 (~0.04ms)，而正常包延迟在 10ms 左右。
# 这证明了 Netem 确实是通过“让一部分包不延迟”来实现乱序的。

# 核心原理：
# Netem 模块本身支持参数叠加。我们可以像搭积木一样，
# 在一行命令里同时指定延迟（Delay）、抖动（Jitter）和丢包率（Loss）。
# 这能模拟出类似“远距离无线传输”或“跨国链路”的不稳定状态。

# 命令语法：tc qdisc change ... netem delay [延迟] [抖动] loss [丢包率]
# 例子：模拟无人机远距离通信：
#       1. 基础延迟 100ms，上下抖动 20ms (80~120ms 之间波动)
#       2. 伴随 10% 的随机丢包
sudo ip netns exec Host3 tc qdisc change dev veth3-ns root netem \
            delay 100ms 20ms loss 10%

# --- 验证方法 ---
# 使用 ping 命令观察延迟波动和丢包情况。
# -c 20: 发送 20 个包，样本足够看清丢包率。
sudo ip netns exec Host1 ping -c 20 10.0.3.2

# 预期输出：
# PING 10.0.3.2 (10.0.3.2) 56(84) bytes of data.
# 64 bytes from 10.0.3.2: icmp_seq=1 ttl=63 time=102 ms  <-- 延迟 > 100ms
# 64 bytes from 10.0.3.2: icmp_seq=2 ttl=63 time=85.4 ms <-- 发生抖动 (变快)
# 64 bytes from 10.0.3.2: icmp_seq=3 ttl=63 time=118 ms  <-- 发生抖动 (变慢)
# ... (中间可能缺失某个 seq) ...                           <-- 发生丢包
#
# --- 10.0.3.2 ping statistics ---
# 20 packets transmitted, 18 received, 10% packet loss, time 19032ms
#
# 结果分析：
# 1. Packet loss: 出现了约 10% 的丢包。
# 2. Time: 延迟不再是固定的，而是在 100ms 附近上下跳动。

# 核心原理：父子级联 (Chaining)
# 我们构建一个处理流水线：
# 1. 第一关 (父节点 root)：使用 TBF 算法限制带宽（把路变窄）。
# 2. 第二关 (子节点 parent)：在 TBF 下面挂载 Netem 算法增加延迟（把路变长）。
# 数据包必须先通过限速，再经过延迟，才能发出去。

# 步骤 1: 设置限速 (父节点 handle 1:) [先删除原来的配置]
# rate 500kbit: 限制带宽为 500Kbps (约 62KB/s)
sudo ip netns exec Host3 tc qdisc del dev veth3-ns root 2>/dev/null 
sudo ip netns exec Host3 tc qdisc change dev veth3-ns \
            root handle 1: tbf rate 500kbit burst 16kbit latency 400ms

# 步骤 2: 挂载延迟 (子节点 parent 1:1)
# parent 1:1 : 表示挂载在 ID 为 1 的规则的第 1 个输出口上
# handle 10: : 给这个 Netem 规则起个 ID 叫 10
sudo ip netns exec Host3 tc qdisc add dev veth3-ns \
            parent 1:1 handle 10: netem delay 100ms

# --- 验证方法 ---
# 这个实验需要验证两个指标：延迟 和 带宽。

# 验证 1: 测延迟 (Ping)
sudo ip netns exec Host1 ping -c 4 10.0.3.2

# 验证 2: 测带宽 (DD + NC)
# 开启接收端 (Host1)
sudo ip netns exec Host1 nc -l -p 8888 > /dev/null &
# 开启发送端 (Host3) 发送 5MB 数据
sudo ip netns exec Host3 bash -c "dd if=/dev/zero bs=1M count=5 | nc 10.0.1.2 8888"

# 预期输出：
# 1. Ping 的结果：
#    time=100 ms 左右。 (证明 Netem 生效)
#
# 2. DD 的结果：【由于TCP的缓冲区问题，这个速度可能稍大于63.4kb/s】
#    5242880 bytes (5.2 MB, 5.0 MiB) copied, 80.xxx s, 63.4 kB/s
# 
# 结果分析：
# 1. 速度被死死卡在 63.4 kB/s (即 500kbit / 8)，证明父节点 TBF 生效。
# 2. Ping 延迟稳定在 100ms，证明子节点 Netem 生效。
# 3. 两者完美共存。

# 1. 实验准备
# 确保 Host3 上的 Python 计算服务正在运行（参考 4.3 节），并在 Host1 上准备好终端。
# 可以现在这个窗口运行下面服务，然后加上 2. 中的延迟，也可以先加延迟在运行服务器。
sudo ip netns exec Host3 python3 math_server.py

# 2. 在 Host3 上设置 70% 的随机丢包，制造“网络风暴”
# root: 根队列规则
# netem: 网络仿真模块
# loss 70%: 丢包率 70%
# 如果已经添加了 veth3-ns 设备，下面使用 tc qdisc change dev veth3-ns
sudo ip netns exec Host3 tc qdisc add dev veth3-ns root netem loss 70%


# 3. 艰难的“握手” (Host1)
# 现在，尝试让 Host1 连接 Host3。请特别留意按下回车后的反应速度。
# Host1 尝试连接 Host3 的计算服务
sudo ip netns exec Host1 nc -v 10.0.3.2 9999
# 现象观察：
# 在没加网络风暴前，你会瞬间看到 Connection succeeded!。
# 但是当前情况下：你可能会发现按下回车后，终端卡住了，过了好几秒（甚至更久）才显示连接成功，
# 或者需要尝试两三次才能连上。这是因为 TCP 建立连接需要的 SYN 包 或 SYN+ACK 包 在路上被丢了。
# 客户端没有收到确认，只能等待超时后重新发送 SYN 包。这个等待时间通常是指数增长的（1秒、2秒、4秒...），导致了明显的滞后感。


# 4. 卡顿的“对话” (交互测试)
# 连接建立后，我们开始输入数字，让 Host3 服务器为我们计算这个数的平方。下面为窗口的显示
# Welcome! Please enter a number:
# (输入 5 并回车)
# ... (静止 3 秒) ...
# Result: 5.0 ^ 2 = 25.0
# (输入 10 并回车)
# Result: 10.0 ^ 2 = 100.0  <-- 这次运气好，没有丢包，瞬间返回
# (输入 8 并回车)
# ... (静止 7 秒) ...
# Result: 8.0 ^ 2 = 64.0
# 现象观察： 你会发现一种诡异的“时快时慢”现象。有时结果瞬间返回，有时像死机了一样卡顿好几秒才蹦出结果


# 5. 幕后英雄 —— 原理解析
# 为什么会卡顿，而不是直接报错退出？这正是 TCP 协议伟大的地方：可靠性优于实时性。
# 当我们输入 5 并发送时，数据包经历了以下过程：
# 发送与丢失：Host1 发送了包含 5 的数据包。运气不好，碰上了那 70% 的概率，包丢了。
# 静默等待：Host1 的 TCP 协议栈启动定时器，等待 Host3 的确认（ACK）。
# 超时重传：时间到了，Host1 发现没收到 ACK，判定数据丢失。
# 它默默地（用户无感知）重新发送了数据包。
# 结果回传：Host3 收到重传包后计算出结果 25.0 并发回。如果这个结果包在回来的路上丢了，
# Host3 也会触发重传机制。
# 结论： 我们在终端看到的“卡顿几秒”，其实是 TCP 在底层为了挽救丢失的数据包，
# 正在进行一次甚至多次的 “超时 -> 重传” 循环。虽然体验变得迟钝，但数据最终准确无误地送达了。

# 6. 清理现场
sudo ip netns exec Host3 tc qdisc del dev veth3-ns root
# 实验结束后，务必删除 TC 规则，恢复网络通畅，否则后续实验会一直卡顿。
# 上述命令删除了 Host3 出口上的所有 TC 规则

# 查看当前接口配置了什么规则
sudo ip netns exec Host3 tc qdisc show dev veth3-ns

# 删除所有规则 (恢复完美网络)。即在网络命名空间 Host3 中，
# 删除网卡 veth3-ns 上的所有流量控制（tc）规则，使其恢复为默认状态。
sudo ip netns exec Host3 tc qdisc del dev veth3-ns root

# --- 1. ip netns：网络命名空间管理 ---

# ip netns add [名称]
# 创建一个新的网络命名空间。
# 例子：创建一个名为 Host1 的隔离环境。
sudo ip netns add Host1

# ip netns list
# 列出当前系统中所有的网络命名空间。
sudo ip netns list

# ip netns del [名称]
# 删除指定的命名空间。注意，该空间内的虚拟网卡、路由表等配置也会一并清除。
sudo ip netns del Host1

# ip netns exec [名称] [命令]
# 在指定的命名空间内部执行命令。这是进入虚拟环境的“传送门”。
# 例子：在 Host1 内部执行 ip addr 命令查看 IP。
sudo ip netns exec Host1 ip addr

# --- 2. ip link：网络接口与网桥管理 ---

# ip link add [设备名] type veth peer name [对端设备名]
# 创建一对 Veth Pair（虚拟网线）。
# 例子：创建一头叫 veth1，另一头叫 veth1-ns 的网线。
sudo ip link add veth1 type veth peer name veth1-ns

# ip link add name [网桥名] type bridge
# 创建一个虚拟网桥（交换机）。
# 例子：创建一个名为 br0 的网桥，用于连接多个网段。
sudo ip link add name br0 type bridge

# ip link set [设备名] netns [命名空间名]
# 将指定的网络接口“移动”到某个命名空间中。
# 例子：把网线的一头 veth1-ns 扔进 Host1 房间里。
sudo ip link set veth1-ns netns Host1

# ip link set [设备名] master [网桥名]
# 将网卡插到网桥（交换机）上。
# 例子：将 veth1 接口连接到 br0 网桥上，使其成为交换机的一个端口。
sudo ip link set veth1 master br0

# ip link set [设备名] up
# 启动网络接口。接口创建后默认是 DOWN（关闭）状态，必须手动启动。
# 注意：网桥 br0 创建后也需要 set up 才能工作。
sudo ip link set veth0 up
sudo ip link set br0 up

# ip link delete [设备名]
# 删除网络接口。
# 如果删除 veth 的一头，另一头会自动消失；如果删除 br0，连接在上面的网卡会断开连接。
sudo ip link delete veth0
sudo ip link delete br0

# --- 3. ip addr：IP 地址管理 ---

# ip addr add [IP地址/掩码] dev [设备名]
# 给指定的网卡配置 IP 地址。
# 例子：给 veth0 配置 10.0.0.1 的 IP，子网掩码为 24位。
sudo ip addr add 10.0.0.1/24 dev veth0

# ip -br addr
# 以精简模式（Brief）查看当前所有的 IP 地址信息，忽略多余的细节。
# 这是一个非常实用的查看命令。
ip -br addr

# --- 4. ip route：路由表管理 ---

# ip route add default via [网关IP]
# 添加默认路由。这是告诉主机：“如果你不知道去哪里，就把包发给这个 IP”。
# 例子：Host1 想上网，必须把包发给宿主机（网关 10.0.1.1）。
sudo ip route add default via 10.0.1.1

# ip route list
# 查看当前的路由表（地图）。
# 检查是否包含 default via ... 行，以及直连路由是否正确。
sudo ip route list

# --- 5. 其他关键系统设置 ---

# sysctl -w net.ipv4.ip_forward=1
# 开启 Linux 内核的 IP 转发功能。
# 只有开启了这个开关，宿主机才能从“普通电脑”变身为“路由器”，
# 允许数据包从一张网卡进入，从另一张网卡出去。
sudo sysctl -w net.ipv4.ip_forward=1

# --- 6. tc：流量控制与网络仿真 (Traffic Control) ---
# 注意：tc 规则通常施加在发送端（出口 Egress）的网卡上。

# tc qdisc add dev [设备名] root netem [参数]
# 为指定设备添加一个根队列规则 (qdisc)，使用 netem (网络仿真) 模块。
# 例子：给 veth3-ns 添加 100ms 的延迟。
sudo ip netns exec Host3 tc qdisc add dev veth3-ns root netem delay 100ms

# tc qdisc change ...
# 修改已有的规则。如果你已经 add 过了，再次修改参数必须用 change。
# 例子：将延迟改为 100ms，并带有 20ms 的随机抖动 (Jitter)。
sudo ip netns exec Host3 tc qdisc change dev veth3-ns root netem delay 100ms 20ms

# netem loss [百分比]
# 模拟丢包。
# 例子：模拟 50% 的极高丢包率。
sudo ip netns exec Host3 tc qdisc change dev veth3-ns root netem loss 50%

# netem reorder [百分比] [相关性] gap [数量]
# 模拟包乱序。
# 例子：每隔 3 个包，第 4 个包就立即发送（不延迟），造成乱序。
sudo ip netns exec Host3 tc qdisc change dev veth3-ns root netem delay 10ms reorder 100% gap 3

# tbf rate [带宽] burst [缓冲] latency [延迟]
# 使用令牌桶过滤器 (Token Bucket Filter) 进行带宽限制。
# 例子：限制带宽为 1Mbit/s。
sudo ip netns exec Host3 tc qdisc change dev veth3-ns root tbf rate 1mbit burst 32kbit latency 400ms

# tc qdisc show dev [设备名]
# 查看当前接口上配置了哪些流量控制规则。
sudo ip netns exec Host3 tc qdisc show dev veth3-ns

# tc qdisc del dev [设备名] root
# 删除设备上的所有根队列规则，恢复网络为默认的“完美状态”。
# 实验结束后务必执行此步骤。
sudo ip netns exec Host3 tc qdisc del dev veth3-ns root