CORE原理.md · JasonL/core-note

CORE原理
=

这个文档主要说明了一下必要的 CORE（Common Open Research Emulator）的安装以及简单的实现原理。

## 1. CORE的主要进程

### 1.1. core-daemon

这个是 CORE 的 [守护进程][1]，它主要负责管理仿真会话、生成节点（[Linux Namespace][2]）、链路（[linux bridge and virtual ethernet peers][3]）、响应 [GUI](#core-pygui) 的控制、提供 gRPC 和 tlv 通信 API。

### 1.2. core-pygui

这是 CORE 新版的基于 Python 的 GUI ，老版的 GUI 基于 tlv 语言，难以维护和改进，目前基本已经停止更新，所以不再赘述，也不推荐使用老版 GUI（以下如非特别声明，所提到的 GUI 均为新版的 core-pygui）。该 GUI 通过 gRPC API 与 [core-daemon](#core-daemon) 进行通信。在 GUI 中，你可以：

* 通过拖拽绘制网络拓扑
* 保存/读取自己绘制的网络拓扑
* 启动仿真中节点的终端

## 2. CORE的安装

### 2.1. 单服务器安装

#### 2.1.1. 源码安装OVS

1. 安装相关依赖

```sh
sudo apt update
sudo apt install build-essential libssl-dev libcap-ng-dev linux-headers-$(uname -r)

sudo apt-get install graphviz autoconf automake bzip2 debhelper dh-autoreconf libssl-dev libtool openssl procps python-all python-qt4 python-twisted-conch python-zopeinterface python-six dkms module-assistant ipsec-tools racoon libc6-dev module-init-tools netbase python-argparse uuid-runtime

sudo apt install python-pip
pip install six
pip install pyftpdlib
pip install tftpy
pip install graphviz
pip install flake8

sudo apt install sparse
sudo apt install wget netcat curl
```

2. 下载OVS

```sh
git clone git://github.com/openvswitch/ovs.git # 最新版本 2.14.0
# 或者直接从网站下载源码（更快一点）：
wget https://www.openvswitch.org/releases/openvswitch-2.15.0.tar.gz

tar -zxvf openvswitch-2.15.0.tar.gz
cd openvswitch-2.15.0/

sudo ./boot.sh
sudo ./configure --with-linux=/lib/modules/$(uname -r)/build
```

3. 编译安装

```sh
sudo make
sudo make install
sudo make modules_install
```

4. 载入核心模组：

```sh
sudo /sbin/modprobe openvswitch
# 确认是否已经载入
/sbin/lsmod | grep openvswitch
```

5. 在启动之前，需要设定OVS所需要的配置文档，设置方式如下：

```sh
export PATH=$PATH:/usr/local/share/openvswitch/scripts
mkdir -p /usr/local/etc/openvswitch
sudo ovsdb-tool create /usr/local/etc/openvswitch/conf.db vswitchd/vswitch.ovsschema
```

6. 开始运行Open vSwitch前的一些准备工作

```sh
sudo mkdir -p /usr/local/var/run/openvswitch

sudo mkdir -p /usr/local/var/log/openvswitch/
cd /usr/local/var/log/openvswitch/
sudo ovsdb-tool create ovsdb-server.log

sudo ovsdb-server --remote=punix:/usr/local/var/run/openvswitch/db.sock \
--remote=db:Open_vSwitch,Open_vSwitch,manager_options \
--private-key=db:Open_vSwitch,SSL,private_key \
--certificate=db:Open_vSwitch,SSL,certificate \
--bootstrap-ca-cert=db:Open_vSwitch,SSL,ca_cert \
--pidfile --detach --log-file
```

7. 接下来，通过OVS提供的工具ovs-ctl来启动OVS,初始化数据库

```sh
sudo ovs-vsctl --no-wait init
sudo ovs-vswitchd --pidfile --detach --log-file
测试
sudo ovs-vsctl add-br br0
sudo ovs-vsctl show
```

8. openvSwitch出现ovsdb-server没有启动的错误（由于在CORE中会调用OVS，因此这一步不需要）

解决方法：

一般解决方式为运行（最好加入开机自运行）如下脚本：
```sh
#!/bin/bash
sudo ovsdb-server --remote=punix:/usr/local/var/run/openvswitch/db.sock --remote=db:Open_vSwitch,Open_vSwitch,manager_options --pidfile --detach
cugjsj123
sudo ovs-vsctl --no-wait init
sudo ovs-vswitchd --pidfile --detach --log-file
```

参考文章：https://blog.csdn.net/u011412226/article/details/80847911

#### 2.1.2. 安装CORE

1. 首先，从 GitHub 上下载 CORE 的源代码（ GitHub 打不开的情况下，后面两种方法比较好）。如果不是用 Git 获取的源代码，还需要解压。

* 访问 [CORE的github](https://github.com/coreemu/core) 页面下载源代码或者某个release版本的代码。
    * `git clone https://github.com/coreeum/core.git`
    * `git clone git://github.com/coreemu/core.git`
    * `wget https://github.com/coreemu/core/releases/tag/release-7.5.1`

2. 进入 CORE 的代码文件夹。

```bash
    # 具体路径视实际情况而定。
    cd core
    ```
3. 执行安装脚本

```bash
    ./install.sh -p /usr/local
    ```
4. 安装 EMANE（可选）

```bash
    inv install-emane -l
    ```

#### 2.1.3. CORE启动脚本

分别创建 `start-core.sh` 和 `stop-core.sh` 两个脚本用于CORE的启动和关闭。

1. `start-core.sh`内容：

```sh
# !/bin/bash
# systemd
sudo -S systemctl daemon-reload <<EOF
root 密码
EOF
sudo systemctl start core-daemon
# sysv
sudo service core-daemon start
```

2. `stop-core.sh` 内容

```sh
# !/bin/bash
sudo -S killall core-daemon<<EOF
root 密码
EOF
```

执行以下命令让脚本能够正常运行：

```bash
chmod a+x start-core.sh stop-core.sh 
```

### 2.2. 分布式安装

为了方便起见，最好几台服务器的 IP 地址固定。

**注意事项**：

* 主服务器安装`openssh-client`
* 从服务器安装`openssh-server`、`xterm`。
* 所有服务器上有一个相同的普通用户名，这个用户名也是我们在主服务器上启动 CORE 的时候所登录的用户名。

1. 依据[单服务器安装](#单服务器安装)在主服务器上安装 CORE 。

2. 在主服务器上编辑 `/etc/core/core.conf` 文件（注意需要 sudo 或者 root 账户）。

```bash
    # *.*.*.* 代表了主服务器的IP地址，这个IP地址用于从服务器向主服务器回传消息。
    distributed_address = *.*.*.*

# EMANE 需要有 controlnet 保证正常启动，所以需要如下配置：
    # 可以根据自己的仿真规模确定 controlnet 的个数。这个地址不是某个服务器的地址，
    # 纯粹是仿真中用的的地址，自己随意指定一个不会冲突的地址段就行了。
    controlnet = core1:172.16.1.0/24 core2:172.16.2.0/24 core3:172.16.3.0/24 core4:172.16.4.0/24 core5:172.16.5.0/24
    emane_event_generate = True
    ```
    
3. 在所有的从服务器上安装 [core_distributed][4]，OpenvSwitch、POX 控制器，EMANE（与单结点安装方式一样）。

```bash
    # 网页下载core_distributed的安装包或者使用wget下载
    wget https://github.com/coreemu/core/releases/download/release-7.5.1/core_distributed_7.5.1_amd64.deb
    # 安装core_distributed
    sudo dpkg -i core_distributed_version_amd64.deb
    #如果碰到依赖问题安装失败，则执行下述命令。
    sudo apt --fix-broken install
    # 上面这个修复依赖问题的命令中应该会自动安装xterm。
    ```

4. 配置 SSH

分布式的 CORE 利用 SSH 在远程服务器上运行命令。远程运行命令作者推荐使用 xterm 作为命令行工具。如果你给节点设置的终端是 xterm，则需要在所有服务器上安装 xterm。

```bash
    sudo apt install xterm
    ```

**以下步骤为配置 root 账户的无密码 SSH 登录**

1). 在主服务器上安装 SSH 客户端并生成密钥

```bash
    sudo apt install openssh-client # 安装 SSH 客户端
    ssh-keygen -o -t rsa -b 4096 -f ~/.ssh/core
    # 生成 SSH 密钥，当系统提示输入密码时，只需按 Enter 键即可生成没有密码的密钥
    ```

2). 在从服务器上安装 SSH 服务端并修改配置文件

```bash
    # 安装 SSH 服务端并打开配置文件
    sudo apt install openssh-server
    sudo vi/vim/gedit /etc/ssh/sshd_config

# 在打开的文件中修改以下内容
    PasswordAuthentication yes
    PermitRootLogin yes

# 重启服务器
    sudo service ssh restart

# 设置 root 密码
    sudo passwd
    ```

3). 在主服务器上将密钥传输到从服务器

```bash
    ssh-copy-id -i ~/.ssh/core root@*.*.*.* # 此处为从服务器 IP，当询问是输入从服务器 root 密码
    ssh -i ~/.ssh/core root@*.*.*.* #测试 SSH 配置
    ```

4). 在从服务器上修改 SSH 配置文件

```bash
    sudo passwd -l root
    sudo vim /etc/ssh/sshd_config

# 修改以下内容
    # 这种修改主要是为了安全问题，自己测试的话修不修改无所谓
    PasswordAuthentication = no
    PermitRootLogin = without-password

# 重启服务
    sudo service ssh restart
    ```

5). 在主服务器上测试并修改配置

```bash
    ssh -i  ~/.ssh/core root@*.*.*.* # 测试无密码登录
    sudo vim /etc/fabric.yaml
    # 写入以下内容：
    connect_kwargs: {"key_filename": "/home/user/.ssh/core"}# user 替换为具体用户名。
    ```

**此外还需要配置普通用户的无密码SSH**

1). 从服务上修改 SSH 配置文件

```bash
    sudo vim /etc/ssh/sshd_config

# 修改以下内容
    PasswordAuthentication = yes

# 重启服务
    sudo service ssh restart
    ```

2). 在主服务器上传输密钥文件

```bash
    ssh-copy-id -i ~/.ssh/core user@*.*.*.* # user是用户名，这里最好所有服务器上有一个相同的普通用户名。此处为从服务器 IP，当询问是输入从服务器 user 密码
    ssh -i ~/.ssh/core root@*.*.*.* #测试 SSH 配置
    ```
5. 在 core-pygui 中：可以在 Session->Servers 中添加分布式服务器。

### 2.3. CORE的安装过程与原理

#### 2.3.1. 安装必须的库

安装 python3-pip 和 python3-venv

```bash
sudo apt install -y python3-pip python3-venv
```

> 关于 Python 的虚拟环境

virtualenv 的关键词是隔离（Isolation）。 它能创造一个包含特定版本的 Python 环境，并且确保 Python 软件包非常干净。它创造性地使用了一些 Shell 和 Python 原有的机制，实现了虚拟环境的功能。

#### 2.3.2. 安装pipx和invoke工具

```bash
python3 -m pip install --user pipx
python3 -m pipx ensurepath
export PATH=$PATH:~/.local/bin
pipx install invoke
```

#### 2.3.3. 开始安装过程

```bash
inv install ${dev} ${verbose} ${local} ${prefix}
```

这里简单讲一下 CORE 在安装过程中所涉及的一些东西。

首先是 `install.sh` 文件，这个 bash 文件中首先检查了传入的参数，然后安装了 python3、python3-venv、pip、pipx、invoke 等软件包。然后执行命令 `inv install` 来安装 CORE。

其次是 `tasks.py` 这个文件是 invoke 会调用的任务文件，其中定义了许多任务（以方法的形式）。CORE 的安装就是调用了其中 `install` 这个任务。

所以想要修改 CORE 的安装过程的话就修改这两个文件。

## 3. CORE仿真原理分析

### 3.1. 调试CORE

以 root 账户身份打开 Pycharm 窗口 1，在窗口 1 中打开 CORE 根文件夹作为新项目。然后选择：`添加解释器`、`Virtualenv 环境`、`现有环境`，解释器位置选择 `/home/user/.cache/pypoetry/virtualenvs/core-Vil9nMce-py3.6/bin/python`（不同的虚拟机的 `core-Vil9nMce-py3.6` 文件夹名称可能会稍有差异）。然后在合适的位置（根据自己需要，CORE 的代码文档）加断点， 在 Pycharm 窗口1中 Debug 运行`core-daemon` 即可。

普通用户身份打开 Pycharm 窗口 2，窗口 2 中打开 CORE 文件夹，解释器同上，加断点后，Debug 运行 `core-pygui`。

目前我把 CORE 的 log 配置改了一下，[修改后的配置文件](./logging.conf)。把这个文件放在 `/etc/core/` 目录下就行了（对于 Ubuntu 来说）。这样的话 CORE 在运行过程中会将 DEBUG 级别一下的 log 全部输出到控制台以及 `/home/username/.coredaemon/core-daemon.log` 中。

另外，如果想要 core-pygui 的详细 log 的话，可以在运行 core-pygui 如下所示：

```bash
core-pygui -l DEBUG
```

DEBUG 是级别，自己可以调，默认是 INFO 级别，DEBUG>INFO。

注：CentOs sudo 不等于 root 账户，要用 root 账户需要先手动进入。 以及不建议以系统服务的形式启动CORE-DAEMON。

### 3.2. 启动 core-daemon

通过 `sudo core-daemon` 或者 CORE 文档中其他方式启动 core-daemon 后，可以在系统中看到一个 `core-daemon` 守护进程（`ps -ef | grep core`），该进程会一直通过 gRPC 通信接口监听消息。以便随时接收 core-pygui 的消息并执行相应动作（开始仿真、移动节点、启动节点终端等）并将仿真中的一些结果信息反馈给 GUI。

### 3.3. 启动 core-pygui

通过 `core-pygui` 命令启动 core-pygui，启动后该进程会生成一个 GUI 界面供用户使用。在 core-pygui 中的操作都将先生成一系列配置信息存储在内存中，当然你也可以吧这些信息保存到硬盘中的一个 `.xml` 文件中。直到点击 **开始仿真按钮** GUI 会把这些信息通过 gRPC 接口发送给 core-daemon 进程。仿真开始后，可以在 GUI 中移动节点，打开节点终端等，这些都会实时与 core-daemon 通信，core-daemon 执行动作后返回结果。

### 3.4. CORE 中的节点类型

我们可以看到 CORE 中的节点主要分为两种类型：CoreNode 和 CoreNetwork。

相关代码主要在 `/core/daemon/core/node` 中。其中，先定义了 NodeBase 类，然后由这个类派生了其他节点类。

#### 3.4.1. CoreNode

这类节点是基于 Linux Namespace 实现的节点，在 GUI 中对应 router、PC 等三层节点。

它们在仿真开始后可以双击节点打开该节点的终端，在终端中执行的命令，CORE 会自动给它加上前缀保证命令在这个节点对应的命名空间中执行。此外，对于每个 CoreNode，CORE 还会为其在硬盘中创建一个临时文件夹作为这个命名空间的根目录用来存储节点相关文件，比如我们的服务脚本。

#### 3.4.2. CoreNetwork

这个节点类由 Linux Bridge 实现，它派生出了其他的 2 层节点，比如：Switch、PtPnet 等（具体可以参考 `/core/node/network.py`）。这些节点的具体实例我在后面统一称为 Network Node。

### 3.5. CORE中网络拓扑的实现

搭建一个 CORE 中的网络，我们需要用的有 CoreNode 和 NetworkNode 以及有线链路（PtPnet）（如果需要的话）。
这两类节点前者由 Linux Namespace 实现，后者（包括有线链路）由 Linux Bridge 实现。

#### 3.5.1. CoreNode到CoreNode的有线链路实现原理

* 实例化一个有线链路（PtPnet）节点，并启动一个 Linux Bridge 与之关联。我们可以在主机的终端中执行 `ip link` 查看，其中名字为 `b.*.` 的即为我们仿真创建的网桥。
* 创建一个 veth-pair 并将其一端放到 CoreNode1 中，一端绑定到 PtPnet 节点的网桥上。
* 同理，通过 veth-pair 连接 CoreNode2 和 PtPnet 节点。

同时，我们可以用 `ip link` 命令查看 CORE 所创建的 veth-pair 中挂载到网桥上的 veth。其中每个 veth 有参数 master，后面跟的网桥名，就是他们挂载的网桥。

#### 3.5.2. CoreNode连接到同一个NetworkNode的实现原理

因为 NetworkNode 本身就是一个网桥，所以猜测大概原理就是通过 veth-pair 连接 CoreNode 和 NetworkNode。具体见 `/core/emulator/session.py` 中的 `add_link()` 方法，这个我在代码解读文档中也有说明。

### 3.6. CORE中服务实现原理

CORE 中的服务，不管多复杂，他们的实现原理都一样（只有 CoreNode 可以配置服务）。他们都继承了 CoreService 这个类。并重写了自己的部分参数和方法。

每个服务有几个比较重要的参数：

* group：指定这个服务属于那一组
* name：服务名字
* executable：这个参数中包含了我们在写服务的配置文件的时候所要用的可执行文件（即我们的主机中有没有安装对应的软件，比如 OVS，EMANE）。
* dependency：顾名思义，依赖项，这里的依赖项指的不是依赖某个软件包，而是依赖某个服务，即这个服务必须在其依赖的服务启动之后启动（启动顺序的问题，CORE 会自行解决，不需要担心，配置好依赖项就行了）
* config: 这个是服务配置文件的文件名列表
* startup: 这个是启动服务的命令
* shutdown: 停止服务的命令
* validate: 验证服务的命令

每个服务最重要的方法就是 `generate_config()` 方法，这个方法会根据文件名来返回对应的配置文件内容。所生成的文件一般会被 startup 或者 shutdown 所使用。

可以看到每个服务都有三个参数是启动、关闭相关的命令，这些命令的执行统统是在对应节点的命名空间中执行的，所以我们在 startup 的命令或者该命令使用的配置文件中配置 OVS 的启动，那么这个节点命名空间中的OVS进程就只能看到这个节点中的 eth 接口。

### 3.7. CORE中的仿真启动过程

这里只是简述一下流程，具体实现细节，代码解读中有。

1. `core-pygui` 通过 gRPC 通信将开始仿真的指令和仿真所需要的参数发给 `core-daemon`。
2. `core-daemon` 读取参数。
3. 创建节点（创建一个命名空间并配置根目录、名字、账户等，或者创建网桥并配置）。
4. 创建链路（根据情况创建 PtPnet、或者简单的 veth-pair，并将对应的 veth 放到命名空间中或挂载到网桥中）。
5. 启动节点的服务（在节点的命名空间中执行每个服务中 startup 参数所配置的命令）。

## 4. OVS运行原理

要启动一个 OVS 服务需要两个进程。一个是 `ovsdb` 进程，一个是 `ovs-vswitchd` 进程。在源码编译安装 OVS 后，在路径 `/etc/openvswitch/`会有一个 `conf.db`文件（如果没有请参考 OVS 在 Linux 系统中启动的教程）。这个 `conf.db` 文件就是 `ovsdb` 进程所使用的数据库文件，里面存储了 `ovs-vswitchd` 进程中创建的网桥、端口等信息。

OVS 服务启动的流程如下：

* 首先要有一个 `*.db` 文件比如 `conf.db` 文件作为 OVS 服务的数据库文件。
* 启动 `ovsdb` 进程，`ovsdb` 进程将 `conf.db`文件作为数据库的存储文件。
* ovsdb 进程会创建一个 `.pid` 文件用于存储 `ovsdb` 进程号，以及一系列 `socket` 文件，其中最重要的是 `.sock` 文件（文件名可以自己指定，`ovs-vswitchd` 进程就是根据这个文件和 `ovsdb` 通信）。
* 初始化数据库（这里就要加上 `.sock` 文件说明是哪个数据库）。
* 启动 `ovs-vswitchd` 进程，根据 `.sock` 文件决定连接到哪个数据库。同时生成 `.pid` 文件存储 `ovs-vswitchd` 进程号。**注：每个数据库只能供一个 `ovs-vswtichd` 进程链接，如果尝试连接已经被连接的数据库则会报错。每个数据库文件也只能被一个 `ovsdb` 进程使用！**

安装 OVS 后，我们会通过一些列命令启动我们的 OVS，那么在这个过程中，都涉及了哪些东西呢？

* conf.db 文件：这个文件是存储我们的交换机信息的数据库文件。
* ovsdb-server 进程：这个进程是 OVS 的数据库进程，OVS 通过这个进程读取、修改数据库文件。
* ovs-vswitchd 进程：这个是 OVS 交换机的守护进程，类似 core-daemon。
* ovs-vsctl：这个命令主要用来对 OVS 数据库进程操作，并管理网桥的“硬件”（网桥，port 等）。
* ovs-ofctl：这个命令主要用来对具体网桥内部的“软件”（流表等）进行管理。

需要说明的是，conf.db 文件、ovsdb-server 和 ovs-vswitchd 进程必须一一对应。不同的 ovs-vswitchd 进程必须连接不同的 ovsdb-server，不同的 ovsdb-server 必须打开不同的 conf.db 文件。

那么，这种一一对应该如何实现呢？通过指定不同的文件名来实现，我们可以把一个空白的数据库文件复制若干份，分别命名。然后再启动 ovsdb-server 进程的时候指定这个进程用的数据库文件的文件名，并同时指定自己的 pid 文件名、log 文件名和 socket 文件名。最后，在启动 ovs-vswitchd 的时候指定连接的 socket 文件名以连接到对应的数据库，同时指定自己的 pid 文件名、log 文件名。最最后，在使用 ovs-vsctl 命令的时候必须指定 socket 文件，但是 ovs-ofctl 命令不需要。

需要注意的是，上面所涉及的文件中我们只需要在命令中写文件名就可以了，OVS 默认会把文件放在硬盘的固定位置，分别是：

* `/usr/local/etc/openvswitch/` 存放数据库文件
* `/usr/local/var/run/openvswitch/` 存放 pid 文件和 socket 文件
* `/usr/local/var/log/openvswitch/` 存放 log 文件

`sudo mkdir` 命令自行创建。

## 5. Linux Namespace

这里主要讲一下 Veth 接口和 Network Namespace 的东西。
为了隔离不同节点的网络，我们需要为每个 CoreNode 创建独立的 Linux Network Namespace。这里的隔离就导致了在某个特定的命名空间（包括我们主机的命名空间）中，我们看不到在其他命名空间中的 veth。

那么，对于进程来说，运行在某个命名空间中的进程也只能看到自己的命名空间中的网络信息，比如 veth。所以，在某个特定命名空间中运行的进程自然也看不到在其他命名空间中的 veth。这也就是为什么我们要在每个 CoreNode 内部都启动一套 OVS 进程（ovsdb-server 和 ovs-vswitchd）。

需要注意的是，CORE 中使用命名空间这个东西只隔离了进程和网络，并指定了每个命名空间的根目录，但是实际上，硬盘中的所有文件是主机和所有命名空间共享的。

## 6. Linux进程与通信

CORE 中的容器可以视为 Linux 主系统中的一个进程。使用命令 `ps -ef | grep vnode` 即可看到我们启动的所有 Vnode 容器。那么在节点的命令行中运行的命令所产生的进程就会使对应节点的 Vnode 进程的子进程（节点的所有服务也是通过在 `core-daemon` 后台中在对应节点的命令行中运行配置文件生成的 `bash` 文件）。

对于 OVS 来说，OVS 只能看到自己的父进程中的网络端口。比如，在 Linux 系统中启动的 OVS 只能看到 Linux 系统中的网络端口，其父进程是 Linux 系统？（这个我就不懂了）。所以利用不同的数据库文件在不同节点中启动 OVS 服务，就可以解决 OVS 进程找不到节点中的端口的问题。

## 7. 关于我在开发OVS服务中遇到的问题

### 7.1. ovs网桥检测不到节点内的eth接口。

这是因为最开始我是在 Python 代码的 `StartSession` 方法中启动的 OVS 的两个进程，也就是说这俩进程运行在主机的命名空间中，所以自然也就无法检测到节点内部的 eth 接口，因为这些接口已经放到了节点的命名空间中。当我在节点中运行 OVS 进程时这个问题就解决了

### 7.2. 多个ovs交换机只有一个生效，即只有一个ovs进程组（ovsdb-server&ovs-vswitchd）以及为什么可以在不同的命名空间中查看其他命名空间中的网桥信息。

这是因为 CORE 中的节点基于 Linux 命名空间，他们只隔离了网络栈和进程，但是文件是共享的。而 OVS 的所有信息均储存在主机的 `/usr/local/etc/openvswitch/` 下的数据库文件中。考虑到同一个数据库文件只能被一个 ovsdb-serveer 进程占用，所以当多个 ovsdb-server 进程想要使用同一个数据库文件时，后启动的 ovsdb-server 就会启动失败。解决方案就是使用不同的数据库文件，可以直接复制原数据库文件并重命名。同时，因为数据库文件都可以访问，所以就可以在某个命名空间中查看其他命名空间中的 OVS 网桥信息。

### 7.3. 为什么大多数paper和教程中只有单个子网（网段）内的SDN

因为简单，不需要配置复杂的功能，只需要配置一些转发规则就可以了。

### 7.4. 如何实现跨子网SDN

1. 考虑到我们用来做终端的节点一般是 CORE 中的 PC 节点，他的 `DefaultRoute` 服务会配置默认路由到自己子网段的 `*.*.*.1` 地址，所以我们在 GUI 的代码中的 `router_nodes` 和 `node_moudles` 中加入了 ovswitch。保证 OVS 交换机不同端口连接的是不同网段，且给 OVS 交换机分配的 IP 地址为 `*.*.*.1`。
2. 那么PC A 要 ping 通交换机另一端连接的 PC B，首先两个 PC 都必须知道自己的网关在哪里，即网关的 MAC 地址。由计算机网络的知识可以知道，PC 是通过 ARP 过程来发现子网内其他接口的 MAC 地址并将 IP 地址和 MAC 地址对应关系放入 ARP 表中（通过 `arp -n` 或 `ip neigh show` 命令可以查看）。那么我们也就需要让 OVS 交换机实现回复 PC 的 APR 请求的功能。这样就可以让 PC 知道自己的数据链路层帧头中的目的 MAC 地址应该填什么而不是填一个广播地址。具体实现见代码（获取 MAC 地址可以用 `ip link`）。
3. 此外，还可以配置 OVS 交换机的 ICMP 报文回复功能来实现 PC 可以 ping 通 OVS 交换机。
4. 在此基础之上，来配置 OVS 交换机真正的跨子网转发的功能了。显然，需要配置的流表应该是匹配子网段，然后进行转发。但是仅仅如此是有问题的，因为我们只是把 PC A 的数据包转发到的 PC B 的子网中，但是数据包的 MAC 层信息还没有修改，这使得目的 MAC 地址仍然是 OVS 交换机在 PC A 的子网中的那个 eth 口的 MAC 地址，显然，PC B 并不会回应这个 ICMP 报文。所以，我们在转发的同时，还需要根据目的 IP 地址来修改数据包的源目的 MAC 地址。如果觉得把这些都写到一个流表内太麻烦，可以考虑先匹配网段，然后把流丢给下一个流表来匹配 IP 地址修改 MAC 信息后转发。这样也比较有可拓展性。如果只是简单地测试该功能的话就随意了。

## 8. 常用命令

<center>常用的命令参考表</center>

**注**：这里列出的一些常用的命令的简单用法，详细内容请 command --help 获取。

[1]: https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&ved=2ahUKEwiYiv-H8f3yAhXP454KHdXeCj8QFnoECA4QAw&url=https%3A%2F%2Fblog.csdn.net%2Fweicao1990%2Farticle%2Fdetails%2F78639549&usg=AOvVaw1OlhnlfLTi5um4OWSgUVU4
[2]: https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&ved=2ahUKEwjb-rTQ8f3yAhXHyp4KHU4nAD4QFnoECBAQAw&url=https%3A%2F%2Fwww.cnblogs.com%2Fsparkdev%2Fp%2F9365405.html&usg=AOvVaw3-T1hCZaL70JhKwk_kLjlJ
[3]: https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=&ved=2ahUKEwjc6Ned8v3yAhVRwZ4KHYW3CEAQFnoECAkQAQ&url=https%3A%2F%2Fblog.csdn.net%2FLL845876425%2Farticle%2Fdetails%2F82156405&usg=AOvVaw06gZB7YrRamOr27GQg5zFq
[4]: https://github.com/coreemu/core/releases/download/release-7.5.1/core_distributed_7.5.1_amd64.deb

JasonL/core-note

简介

发行版

贡献者

近期动态

JasonL/core-note .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

JasonL/core-note