P4+ONOS 学习笔记
文件构造
.
├── app //里面有很多java文件，但不知道是什么
├── docker-compose.yml //Compose 是一个用于定义和运行多容器 Docker 的工具。使用 YAML 文件来配置应用程序的服务。
├── EXERCISE-1.md
├── EXERCISE-2.md
├── EXERCISE-3.md
├── EXERCISE-4.md
├── EXERCISE-5.md
├── EXERCISE-6.md
├── EXERCISE-7.md
├── EXERCISE-8.md
├── img //一些图片
├── LICENSE //至今不知道这个有啥用
├── Makefile //make运行命令的文件
├── mininet //构建mininet的一些json和python 文件
├── p4src //一些要运行的P4文件
├── ptf //暂且不知道
├── README.md
├── solution //构建整个项目的解决办法，exercise对应的answer
├── util //不知道这个里面的东西有什么用
└── yang //未知
MakeFile
mkfile_path := $(abspath $(lastword $(MAKEFILE_LIST)))
curr_dir := $(patsubst %/,%,$(dir $(mkfile_path)))
include util/docker/Makefile.vars
onos_url := http://localhost:8181/onos
onos_curl := curl --fail -sSL --user onos:rocks --noproxy localhost
app_name := org.onosproject.ngsdn-tutorial
NGSDN_TUTORIAL_SUDO ?=
default:
$(error Please specify a make target (see README.md))
_docker_pull_all:
docker pull ${ONOS_IMG}@${ONOS_SHA}
docker tag ${ONOS_IMG}@${ONOS_SHA} ${ONOS_IMG}
docker pull ${P4RT_SH_IMG}@${P4RT_SH_SHA}
docker tag ${P4RT_SH_IMG}@${P4RT_SH_SHA} ${P4RT_SH_IMG}
docker pull ${P4C_IMG}@${P4C_SHA}
docker tag ${P4C_IMG}@${P4C_SHA} ${P4C_IMG}
docker pull ${STRATUM_BMV2_IMG}@${STRATUM_BMV2_SHA}
docker tag ${STRATUM_BMV2_IMG}@${STRATUM_BMV2_SHA} ${STRATUM_BMV2_IMG}
docker pull ${MVN_IMG}@${MVN_SHA}
docker tag ${MVN_IMG}@${MVN_SHA} ${MVN_IMG}
docker pull ${GNMI_CLI_IMG}@${GNMI_CLI_SHA}
docker tag ${GNMI_CLI_IMG}@${GNMI_CLI_SHA} ${GNMI_CLI_IMG}
docker pull ${YANG_IMG}@${YANG_SHA}
docker tag ${YANG_IMG}@${YANG_SHA} ${YANG_IMG}
docker pull ${SSHPASS_IMG}@${SSHPASS_SHA}
docker tag ${SSHPASS_IMG}@${SSHPASS_SHA} ${SSHPASS_IMG}
deps: _docker_pull_all
_start:
$(info *** Starting ONOS and Mininet (${NGSDN_TOPO_PY})... )
@mkdir -p tmp/onos
@NGSDN_TOPO_PY=${NGSDN_TOPO_PY} docker-compose up -d
start: NGSDN_TOPO_PY := topo-v6.py
start: _start
start-v4: NGSDN_TOPO_PY := topo-v4.py
start-v4: _start
start-gtp: NGSDN_TOPO_PY := topo-gtp.py
start-gtp: _start
stop:
$(info *** Stopping ONOS and Mininet...)
@NGSDN_TOPO_PY=foo docker-compose down -t0
restart: reset start
onos-cli:
$(info *** Connecting to the ONOS CLI... password: rocks)
$(info *** Top exit press Ctrl-D)
@ssh -o "UserKnownHostsFile=/dev/null" -o "StrictHostKeyChecking=no" -o LogLevel=ERROR -p 8101 onos@localhost
onos-log:
docker-compose logs -f onos
onos-ui:
open ${onos_url}/ui
mn-cli:
$(info *** Attaching to Mininet CLI...)
$(info *** To detach press Ctrl-D (Mininet will keep running))
-@docker attach --detach-keys "ctrl-d" $(shell docker-compose ps -q mininet) || echo "*** Detached from Mininet CLI"
mn-log:
docker logs -f mininet
_netcfg:
$(info *** Pushing ${NGSDN_NETCFG_JSON} to ONOS...)
${onos_curl} -X POST -H 'Content-Type:application/json' \
${onos_url}/v1/network/configuration -d@./mininet/${NGSDN_NETCFG_JSON}
@echo
netcfg: NGSDN_NETCFG_JSON := netcfg.json
netcfg: _netcfg
netcfg-sr: NGSDN_NETCFG_JSON := netcfg-sr.json
netcfg-sr: _netcfg
netcfg-gtp: NGSDN_NETCFG_JSON := netcfg-gtp.json
netcfg-gtp: _netcfg
flowrule-gtp:
$(info *** Pushing flowrule-gtp.json to ONOS...)
${onos_curl} -X POST -H 'Content-Type:application/json' \
${onos_url}/v1/flows?appId=rest-api -d@./mininet/flowrule-gtp.json
@echo
flowrule-clean:
$(info *** Removing all flows installed via REST APIs...)
${onos_curl} -X DELETE -H 'Content-Type:application/json' \
${onos_url}/v1/flows/application/rest-api
@echo
reset: stop
-$(NGSDN_TUTORIAL_SUDO) rm -rf ./tmp
clean:
-$(NGSDN_TUTORIAL_SUDO) rm -rf p4src/build
-$(NGSDN_TUTORIAL_SUDO) rm -rf app/target
-$(NGSDN_TUTORIAL_SUDO) rm -rf app/src/main/resources/bmv2.json
-$(NGSDN_TUTORIAL_SUDO) rm -rf app/src/main/resources/p4info.txt
p4-build: p4src/main.p4
$(info *** Building P4 program...)
@mkdir -p p4src/build
docker run --rm -v ${curr_dir}:/workdir -w /workdir ${P4C_IMG} \
p4c-bm2-ss --arch v1model -o p4src/build/bmv2.json \
--p4runtime-files p4src/build/p4info.txt --Wdisable=unsupported \
p4src/main.p4
@echo "*** P4 program compiled successfully! Output files are in p4src/build"
p4-test:
@cd ptf && PTF_DOCKER_IMG=$(STRATUM_BMV2_IMG) ./run_tests $(TEST)
_copy_p4c_out:
$(info *** Copying p4c outputs to app resources...)
@mkdir -p app/src/main/resources
cp -f p4src/build/p4info.txt app/src/main/resources/
cp -f p4src/build/bmv2.json app/src/main/resources/
_mvn_package:
$(info *** Building ONOS app...)
@mkdir -p app/target
@docker run --rm -v ${curr_dir}/app:/mvn-src -w /mvn-src ${MVN_IMG} mvn -o clean package
app-build: p4-build _copy_p4c_out _mvn_package
$(info *** ONOS app .oar package created succesfully)
@ls -1 app/target/*.oar
app-install:
$(info *** Installing and activating app in ONOS...)
${onos_curl} -X POST -HContent-Type:application/octet-stream \
'${onos_url}/v1/applications?activate=true' \
--data-binary @app/target/ngsdn-tutorial-1.0-SNAPSHOT.oar
@echo
app-uninstall:
$(info *** Uninstalling app from ONOS (if present)...)
-${onos_curl} -X DELETE ${onos_url}/v1/applications/${app_name}
@echo
app-reload: app-uninstall app-install
yang-tools:
docker run --rm -it -v ${curr_dir}/yang/demo-port.yang:/models/demo-port.yang ${YANG_IMG}
solution-apply:
mkdir working_copy
cp -r app working_copy/app
cp -r p4src working_copy/p4src
cp -r ptf working_copy/ptf
cp -r mininet working_copy/mininet
rsync -r solution/ ./
solution-revert:
test -d working_copy
$(NGSDN_TUTORIAL_SUDO) rm -rf ./app/*
$(NGSDN_TUTORIAL_SUDO) rm -rf ./p4src/*
$(NGSDN_TUTORIAL_SUDO) rm -rf ./ptf/*
$(NGSDN_TUTORIAL_SUDO) rm -rf ./mininet/*
cp -r working_copy/* ./
$(NGSDN_TUTORIAL_SUDO) rm -rf working_copy/
check:
make reset
# P4 starter code and app should compile
make p4-build
make app-build
# Check solution
make solution-apply
make start
make p4-build
make p4-test
make app-build
sleep 30
make app-reload
sleep 10
make netcfg
sleep 10
# The first ping(s) might fail because of a known race condition in the
# L2BridgingComponenet. Ping all hosts.
-util/mn-cmd h1a ping -c 1 2001:1:1::b
util/mn-cmd h1a ping -c 1 2001:1:1::b
-util/mn-cmd h1b ping -c 1 2001:1:1::c
util/mn-cmd h1b ping -c 1 2001:1:1::c
-util/mn-cmd h2 ping -c 1 2001:1:1::b
util/mn-cmd h2 ping -c 1 2001:1:1::b
util/mn-cmd h2 ping -c 1 2001:1:1::a
util/mn-cmd h2 ping -c 1 2001:1:1::c
-util/mn-cmd h3 ping -c 1 2001:1:2::1
util/mn-cmd h3 ping -c 1 2001:1:2::1
util/mn-cmd h3 ping -c 1 2001:1:1::a
util/mn-cmd h3 ping -c 1 2001:1:1::b
util/mn-cmd h3 ping -c 1 2001:1:1::c
-util/mn-cmd h4 ping -c 1 2001:1:2::1
util/mn-cmd h4 ping -c 1 2001:1:2::1
util/mn-cmd h4 ping -c 1 2001:1:1::a
util/mn-cmd h4 ping -c 1 2001:1:1::b
util/mn-cmd h4 ping -c 1 2001:1:1::c
make stop
make solution-revert
check-sr:
make reset
make start-v4
sleep 45
util/onos-cmd app activate segmentrouting
util/onos-cmd app activate pipelines.fabric
sleep 15
make netcfg-sr
sleep 20
util/mn-cmd h1a ping -c 1 172.16.1.3
util/mn-cmd h1b ping -c 1 172.16.1.3
util/mn-cmd h2 ping -c 1 172.16.2.254
sleep 5
util/mn-cmd h2 ping -c 1 172.16.1.1
util/mn-cmd h2 ping -c 1 172.16.1.2
util/mn-cmd h2 ping -c 1 172.16.1.3
# ping from h3 and h4 should not work without the solution
! util/mn-cmd h3 ping -c 1 172.16.3.254
! util/mn-cmd h4 ping -c 1 172.16.4.254
make solution-apply
make netcfg-sr
sleep 20
util/mn-cmd h3 ping -c 1 172.16.3.254
util/mn-cmd h4 ping -c 1 172.16.4.254
sleep 5
util/mn-cmd h3 ping -c 1 172.16.1.1
util/mn-cmd h3 ping -c 1 172.16.1.2
util/mn-cmd h3 ping -c 1 172.16.1.3
util/mn-cmd h3 ping -c 1 172.16.2.1
util/mn-cmd h3 ping -c 1 172.16.4.1
util/mn-cmd h4 ping -c 1 172.16.1.1
util/mn-cmd h4 ping -c 1 172.16.1.2
util/mn-cmd h4 ping -c 1 172.16.1.3
util/mn-cmd h4 ping -c 1 172.16.2.1
make stop
make solution-revert
check-gtp:
make reset
make start-gtp
sleep 45
util/onos-cmd app activate segmentrouting
util/onos-cmd app activate pipelines.fabric
util/onos-cmd app activate netcfghostprovider
sleep 15
make solution-apply
make netcfg-gtp
sleep 20
util/mn-cmd enodeb ping -c 1 10.0.100.254
util/mn-cmd pdn ping -c 1 10.0.200.254
util/onos-cmd route-add 17.0.0.0/24 10.0.100.1
make flowrule-gtp
# util/mn-cmd requires a TTY because it uses docker -it option
# hence we use screen for putting it in the background
screen -d -m util/mn-cmd pdn /mininet/send-udp.py
util/mn-cmd enodeb /mininet/recv-gtp.py -e
make stop
make solution-revert
用docker的p4c来编译P4文件
mkfile_path:=$(abspath $(lastword $(MAKEFILE_LIST)))
curr_dir := $(patsubst %/,%,$(dir $(mkfile_path)))
#include /home/sdn/ngsdn-tutorial/util/docker/Makefile.vars
p4-test: p4src/basic.p4
@mkdir -p p4src/build
docker run --rm -v $(curr_dir):/test -w /test opennetworking/p4c:stable \
p4c-bm2-ss --arch v1model -o p4src/build/bmv2.json \
--p4runtime-files p4src/build/p4info.txt --Wdisable=unsupported \
p4src/basic.p4
make start #启动ONOS和mininet
对应的是Makefile中这些代码
_start:
$(info *** Starting ONOS and Mininet (${NGSDN_TOPO_PY})... )
@mkdir -p tmp/onos
@NGSDN_TOPO_PY=${NGSDN_TOPO_PY} docker-compose up -d
start: NGSDN_TOPO_PY := topo-v6.py
start: _start
start-v4: NGSDN_TOPO_PY := topo-v4.py
start-v4: _start
start-gtp: NGSDN_TOPO_PY := topo-gtp.py
start-gtp: _start
本质上是先这行了docker-compose,再用启动的Container执行了topo-v6.py的mininet脚本。
docker-compose.yml 如下
version: "3"
services:
mininet:
image: opennetworking/ngsdn-tutorial:stratum_bmv2
hostname: mininet
container_name: mininet
privileged: true
tty: true
stdin_open: true
restart: always
volumes:
- ./tmp:/tmp
- ./mininet:/mininet
ports:
- "50001:50001"
- "50002:50002"
- "50003:50003"
- "50004:50004"
# NGSDN_TOPO_PY is a Python-based Mininet script defining the topology. Its
# value is passed to docker-compose as an environment variable, defined in
# the Makefile.
entrypoint: "/mininet/${NGSDN_TOPO_PY}"
onos:
image: onosproject/onos:2.2.2
hostname: onos
container_name: onos
ports:
- "8181:8181" # HTTP
- "8101:8101" # SSH (CLI)
volumes:
- ./tmp/onos:/root/onos/apache-karaf-4.2.8/data/tmp
environment:
- ONOS_APPS=gui2,drivers.bmv2,lldpprovider,hostprovider
links:
- mininet
这个文件配置了一些docker容器的启动参数，并且用
docker compose up -d
来在后台启动，docker-compose是用于启动多个镜像比较方便的东西，不过我不会配置就是了。。。
P4runtime
make p4-build #编译P4
make start #用Docker容器来启动mininet和ONOS
make mn-log #打印Miniet 的信息
util/p4rt-sh --grpc-addr localhost:50001 --config p4src/build/p4info.txt,p4src/build/bmv2.json --election-id 0,1
用以上的命令来讲编译好的P4文件载入到mininet中的交换机中去
在启动了mininet以及ONOS的docker服务器之后，
Insert P4Runtime table entries
To be able to forward ping packets, we need to add two table entries on l2_exact_table in leaf1 – one that matches on destination MAC address of h1b and forwards traffic to port 4 (where h1b is attached), and vice versa (h1a is attached to port 3).
Let’s use the P4Runtime shell to create and insert such entries. Looking at the P4Info file, use the commands below to insert the following two entries in the l2_exact_table:
| Match (Ethernet dest) | Egress port number |
|---|---|
00:00:00:00:00:1B | 4 |
00:00:00:00:00:1A | 3 |
To create a table entry object:
te是一个entry也就是我们要插入的流表的一个entry
P4Runtime sh >>> te = table_entry["P4INFO-TABLE-NAME"](action = "<P4INFO-ACTION-NAME>")
Make sure to use the fully qualified name for each entity, e.g. IngressPipeImpl.l2_exact_table, IngressPipeImpl.set_egress_port, etc.
这里P4INFO-TABLE-NAME是table的完整名称，从gressname.tablename的形式。
是action的名称的形式，也是gressname.actionname的形式，不可以用tab键自动补全
To specify a match field:
P4Runtime sh >>> te.match["P4INFO-MATCH-FIELD-NAME"] = ("VALUE")
VALUE can be a MAC address expressed in Colon-Hexadecimal notation (e.g., 00:11:22:AA:BB:CC), or IP address in dot notation, or an arbitrary string. Based on the information contained in the P4Info, P4Runtime shell will internally convert that value to a Protobuf byte string.
P4INFO-MATCH-FIELD-NAME:这个是tuple.first，VALUE填的是前面这个P4INFO-MATCH-FIELD-NAME对应的值。可以看做是匹配的key
The specify the values for the table entry action parameters:
P4Runtime sh >>> te.action["P4INFO-ACTION-PARAM-NAME"] = ("VALUE")
P4INFO-ACTION-PARAM-NAME是tuple.second，也就是键所对应的值。
You can show the table entry object in Protobuf Text format, using the print command:
P4Runtime sh >>> print(te)
The shell internally takes care of populating the fields of the corresponding Protobuf message by using the content of the P4Info file.
To insert the entry (this will issue a P4Runtime Write RPC to the switch):
P4Runtime sh >>> te.insert()
To read table entries from the switch (this will issue a P4Runtime Read RPC):
P4Runtime sh >>> for te in table_entry["P4INFO-TABLE-NAME"].read():
...: print(te)
...:
查询P4Runtime Shell 的命令：https://github.com/p4lang/p4runtime-shell
YANG&NETCONFIG
2.5.3 YAGN建模语言介绍 NETCONF YANG原理
YANG是专门为NETCONF协议设计的数据建模语言，用来为NETCONF协议设计可操作的配置数据、状态数
据模型、远程调用（RPCs)模型和通知机制等。
bash-4.4# ls /models
demo-port.yang hercules ietf openconfig
里面存储有这些文件。。。
Using ONOS as the Control Plane
首先是
sudo make restart
用于重新装载这个文件，用sudo因为需要删除一些文件，如果权限不够，就删不干净
restart: reset start
restart分为reset和start两个步骤
在docker-compose.yml中
onos:
image: onosproject/onos:2.2.2
hostname: onos
container_name: onos
ports:
- "8181:8181" # HTTP
- "8101:8101" # SSH (CLI)
volumes:
- ./tmp/onos:/root/onos/apache-karaf-4.2.8/data/tmp
environment:
- ONOS_APPS=gui2,drivers.bmv2,lldpprovider,hostprovider
links:
- mininet
gui2: ONOS web user interface (available at http://localhost:8181/onos/ui)drivers.bmv2: BMv2/Stratum drivers based on P4Runtime, gNMI, and gNOIlldpprovider: LLDP-based link discovery application (used in Exercise 4)hostprovider: Host discovery application (used in Exercise 4)
make onos-cli
这个本质上就是通过ssh连接ONOS的服务器，不过这个ONOS客户端好像布置在了本地？
onos-cli:
$(info *** Connecting to the ONOS CLI... password: rocks)
$(info *** Top exit press Ctrl-D)
@ssh -o "UserKnownHostsFile=/dev/null" -o "StrictHostKeyChecking=no" -o LogLevel=ERROR -p 8101 onos@localhost
同时通过浏览器也可以访问
page: http://localhost:8181/onos/ui/
username: onos
password: rocks
通过在ONOS-CLI中输入以下的命令可以获得到所有的app的信息
onos> apps -a -s
禁用LLDPprovider，这玩意似乎是LLDP协议的一个设备发现程序？现在用不到
onos> app deactivate lldpprovider
接下来构建ONOS app 包括[pipeconf](# 关于Pipeconf)
make app-build
其的命令是
app-build: p4-build _copy_p4c_out _mvn_package
$(info *** ONOS app .oar package created succesfully)
@ls -1 app/target/*.oar
p4-build就是编译P4
_copy_p4c_out就是复制文件到Java项目的目录下
@mkdir -p app/src/main/resources
cp -f p4src/build/p4info.txt app/src/main/resources/
cp -f p4src/build/bmv2.json app/src/main/resources/
_mvn_package
会用Docker的 mvn生成一个app/target/ngsdn-tutorial-1.0-SNAPSHOT.oar文件，用于安装程序在running的ONOS instance中
make app-reload
用于安装app在ONOS中并且激活它
其命令是
app-reload: app-uninstall app-install
app-uninstall的命令如下
onos_url := http://localhost:8181/onos
onos_curl := curl --fail -sSL --user onos:rocks --noproxy localhost
app_name := org.onosproject.ngsdn-tutorial
app-uninstall:
$(info *** Uninstalling app from ONOS (if present)...)
-${onos_curl} -X DELETE ${onos_url}/v1/applications/${app_name}
@echo
其中额curl似乎有点难受 --fail是失败的话不打印信息 -sSL是silent的意思再加上S表示 show Error L表示自动跳转
有些网域需要 HTTP 认证，这时 curl 需要用到 --user 或者 -u 参数。
$ curl --user name:password example.com
–noproxy localhost
--noproxy List of hosts which do not use proxy
-X DELETE表示是DELETE方法 ，也就是它是通过HTTP请求来和ONOS的这个服务器进行交互的。。。。吐了。。。
删除的竟然是网站上的资源，也就是说它是通过网站发起请求，然后删除的。。。。。竟然用了网站的API
app-install:
$(info *** Installing and activating app in ONOS...)
${onos_curl} -X POST -HContent-Type:application/octet-stream \
'${onos_url}/v1/applications?activate=true' \
--data-binary @app/target/ngsdn-tutorial-1.0-SNAPSHOT.oar
@echo
app-install是用POST方法
-H参数添加 HTTP 请求的标头
Content-Type是媒体类型，也就是传输的数据类型
–data-binary 以二进制的方式post数据 直接把oar文件给post上去了，好厉害的样子
Alternatively, you can show the list of registered pipeconfs using the ONOS CLI (make onos-cli) command:
onos> pipeconfs
接下来要用
make netconf
其代码如下：
_netcfg:
$(info *** Pushing ${NGSDN_NETCFG_JSON} to ONOS...)
${onos_curl} -X POST -H 'Content-Type:application/json' \
${onos_url}/v1/network/configuration -d@./mininet/${NGSDN_NETCFG_JSON}
@echo
netcfg: NGSDN_NETCFG_JSON := netcfg.json
netcfg: _netcfg
这里用的是-d
因此看看(2条消息) Curl命令的data, data-ascii, data-binary, data-raw和data-urlencode选项详解
关于Pipeconf
来源于这片文章：(2条消息) ONOS架构中的YANG、P4 Runtime_weixin_41819513的博客-CSDN博客
这是其中的一部分截取：
假设现在我们写好了P4程序，需要用ONOS去控制这样的设备，那我们就需要开发一个ONOS应用，这类应用我们把它称作Pipeconf，pipeline configuration，编译打包完的这个Pipeconf.oar文件加载到控制器之后，控制器就知道P4设备里将要运行着一个什么样的流水线，该如何去控制和使用这个流水线，同时控制器会帮我们把这个P4程序下发安装到我们的P4设备上。
Pipeconf是以一个ONOS应用的形式呈现的，编译完就是我们熟悉的.oar文件。里面打包了一切必要的数据和代码，主要包括三个方面：
首先，是pipeline的模型，这是对P4程序解析后得到的结果，包括转发表的模型、计数器的模型等等。
第二，设备驱动功能。这个特别重要。这里面包含了这么几个要素：
(1)是Pipeline’s Interpreter，转发表流水线的解释器，它主要做的是类型转换的工作，这个很重要，我们稍后会看到。
(2)是一个可选的FlowObjective ’s Pipeliner，这个其实在OpenFlow中对应的也有。FlowRule是具体表示了一条转发表，而FlowObjective是我们想要达成的转发目标，FlowObjective是FlowRule的更高层的抽象。一个转发目标可能对应到一个特定设备上的多条流表。这个Pipeliner就负责进行FlowObjective到FlowRule的转换。
(3)是一个可选的PortStatisticsDiscovery。比方说，我们写的P4程序里对端口的数据收发做了统计，我们在控制器上需要读取这些统计值，那么我们就需要给它加一个PortStatisticsDiscovery，端口统计发现这样的驱动功能。这个是可选的。如果说我们就想做一个ping通的实验，不需要这个统计功能，那么OK，就省去了这块的功夫。
第三，是设备平台相关的一些扩展。这些是P4程序编译后的产物，包括了BMv2 的JSON文件，Tofino的Binary固件，还有P4Info这个文件。其中P4Info很关键，它是在P4 Runtime中，把ID号和具体名字做映射的时候用的。
PI架构。。。.
学习ONOS的UI界面：https://wiki.onosproject.org/x/OYMg
ONOS gRPC的log
开启和关闭
onos> cfg set org.onosproject.grpc.ctl.GrpcChannelControllerImpl enableMessageLog true
onos> cfg set org.onosproject.grpc.ctl.GrpcChannelControllerImpl enableMessageLog false
ngsdn-tutorial/tmp/onos下
grpc___mininet_开头的文件便是每个交换机？的log吗。。。
Note: Remember to disable the gRPC message logging in ONOS when you’re done, to avoid affecting performances:
Enabling ONOS Built-in Services
首先让我们看看P4的大概流程图，这是Controller和P4互相传输信息的大致流程。。。
让我们来看看ONOS的JAVA代码
看一下初始化loader的代码
/*
* Copyright 2019-present Open Networking Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ngsdn.tutorial.pipeconf;
import org.onosproject.net.behaviour.Pipeliner;
import org.onosproject.net.driver.DriverAdminService;
import org.onosproject.net.driver.DriverProvider;
import org.onosproject.net.pi.model.DefaultPiPipeconf;
import org.onosproject.net.pi.model.PiPipeconf;
import org.onosproject.net.pi.model.PiPipelineInterpreter;
import org.onosproject.net.pi.model.PiPipelineModel;
import org.onosproject.net.pi.service.PiPipeconfService;
import org.onosproject.p4runtime.model.P4InfoParser;
import org.onosproject.p4runtime.model.P4InfoParserException;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
import org.osgi.service.component.annotations.Reference;
import org.osgi.service.component.annotations.ReferenceCardinality;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.net.URL;
import java.util.List;
import java.util.stream.Collectors;
import static org.onosproject.net.pi.model.PiPipeconf.ExtensionType.BMV2_JSON;
import static org.onosproject.net.pi.model.PiPipeconf.ExtensionType.P4_INFO_TEXT;
import static org.onosproject.ngsdn.tutorial.AppConstants.PIPECONF_ID;
/**
* Component that builds and register the pipeconf at app activation.
*/
@Component(immediate = true, service = PipeconfLoader.class)
public final class PipeconfLoader {
private final Logger log = LoggerFactory.getLogger(getClass());
private static final String P4INFO_PATH = "/p4info.txt";
private static final String BMV2_JSON_PATH = "/bmv2.json";
//这是集合中的关系，cardinality是集合与集合之间的关系，比如说 0..1 或者 1..1的关系
//ReferenceCardinality.MANDATORY在这里是1..1的关系
@Reference(cardinality = ReferenceCardinality.MANDATORY)
private PiPipeconfService pipeconfService;
@Reference(cardinality = ReferenceCardinality.MANDATORY)
private DriverAdminService driverAdminService; //驱动管理服务?
//指定怎么Activatede 的策略。
@Activate
public void activate() {
// Registers the pipeconf at component activation.
if (pipeconfService.getPipeconf(PIPECONF_ID).isPresent()) {
// Remove first if already registered, to support reloading of the
// pipeconf during the tutorial.
pipeconfService.unregister(PIPECONF_ID);
}
removePipeconfDrivers();
try {
pipeconfService.register(buildPipeconf());
} catch (P4InfoParserException e) {
log.error("Unable to register " + PIPECONF_ID, e);
}
}
//这。。。。。
@Deactivate
public void deactivate() {
// Do nothing.
}
//创建Pipeconf
private PiPipeconf buildPipeconf() throws P4InfoParserException {
//这个PipeconfLoader似乎是一个加载类？
final URL p4InfoUrl = PipeconfLoader.class.getResource(P4INFO_PATH);
final URL bmv2JsonUrlUrl = PipeconfLoader.class.getResource(BMV2_JSON_PATH);
final PiPipelineModel pipelineModel = P4InfoParser.parse(p4InfoUrl);
return DefaultPiPipeconf.builder()
.withId(PIPECONF_ID)
.withPipelineModel(pipelineModel)
.addBehaviour(PiPipelineInterpreter.class, InterpreterImpl.class)
.addBehaviour(Pipeliner.class, PipelinerImpl.class)
.addExtension(P4_INFO_TEXT, p4InfoUrl)
.addExtension(BMV2_JSON, bmv2JsonUrlUrl)
.build();
}
private void removePipeconfDrivers() {
List<DriverProvider> driverProvidersToRemove = driverAdminService
.getProviders().stream()
.filter(p -> p.getDrivers().stream()
.anyMatch(d -> d.name().endsWith(PIPECONF_ID.id())))
.collect(Collectors.toList());
if (driverProvidersToRemove.isEmpty()) {
return;
}
log.info("Found {} outdated drivers for pipeconf '{}', removing...",
driverProvidersToRemove.size(), PIPECONF_ID);
driverProvidersToRemove.forEach(driverAdminService::unregisterProvider);
}
}
这是一个Interpreter的代码，说白了是控制器把P4的代码翻译成ONOS能看得懂的内容，不过为什么要这么蠢的内容一致，我也不清楚。。。。
/*
* Copyright 2019-present Open Networking Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ngsdn.tutorial.pipeconf;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import org.onlab.packet.DeserializationException;
import org.onlab.packet.Ethernet;
import org.onlab.util.ImmutableByteSequence;
import org.onosproject.net.ConnectPoint;
import org.onosproject.net.DeviceId;
import org.onosproject.net.Port;
import org.onosproject.net.PortNumber;
import org.onosproject.net.device.DeviceService;
import org.onosproject.net.driver.AbstractHandlerBehaviour;
import org.onosproject.net.flow.TrafficTreatment;
import org.onosproject.net.flow.criteria.Criterion;
import org.onosproject.net.packet.DefaultInboundPacket;
import org.onosproject.net.packet.InboundPacket;
import org.onosproject.net.packet.OutboundPacket;
import org.onosproject.net.pi.model.PiMatchFieldId;
import org.onosproject.net.pi.model.PiPacketMetadataId;
import org.onosproject.net.pi.model.PiPipelineInterpreter;
import org.onosproject.net.pi.model.PiTableId;
import org.onosproject.net.pi.runtime.PiAction;
import org.onosproject.net.pi.runtime.PiPacketMetadata;
import org.onosproject.net.pi.runtime.PiPacketOperation;
import java.nio.ByteBuffer;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import static java.lang.String.format;
import static java.util.stream.Collectors.toList;
import static org.onlab.util.ImmutableByteSequence.copyFrom;
import static org.onosproject.net.PortNumber.CONTROLLER;
import static org.onosproject.net.PortNumber.FLOOD;
import static org.onosproject.net.flow.instructions.Instruction.Type.OUTPUT;
import static org.onosproject.net.flow.instructions.Instructions.OutputInstruction;
import static org.onosproject.net.pi.model.PiPacketOperationType.PACKET_OUT;
import static org.onosproject.ngsdn.tutorial.AppConstants.CPU_PORT_ID;
/**
* Interpreter implementation.
*/
public class InterpreterImpl extends AbstractHandlerBehaviour
implements PiPipelineInterpreter {
// From v1model.p4
private static final int V1MODEL_PORT_BITWIDTH = 9;
// From P4Info.
private static final Map<Criterion.Type, String> CRITERION_MAP =
new ImmutableMap.Builder<Criterion.Type, String>()
.put(Criterion.Type.IN_PORT, "standard_metadata.ingress_port")
.put(Criterion.Type.ETH_DST, "hdr.ethernet.dst_addr")
.put(Criterion.Type.ETH_SRC, "hdr.ethernet.src_addr")
.put(Criterion.Type.ETH_TYPE, "hdr.ethernet.ether_type")
.put(Criterion.Type.IPV6_DST, "hdr.ipv6.dst_addr")
.put(Criterion.Type.IP_PROTO, "local_metadata.ip_proto")
.put(Criterion.Type.ICMPV4_TYPE, "local_metadata.icmp_type")
.put(Criterion.Type.ICMPV6_TYPE, "local_metadata.icmp_type")
.build();
//这里好多put，其实都是对一个对象的put而不是层层嵌套
/**
* Returns a collection of PI packet operations populated with metadata
* specific for this pipeconf and equivalent to the given ONOS
* OutboundPacket instance.
*
* @param packet ONOS OutboundPacket
* @return collection of PI packet operations
* @throws PiInterpreterException if the packet treatments cannot be
* executed by this pipeline
*/
/**
*outboundpacket —— 合成数据包是协议无关的，表示是从控制器发出到网络上的信息。这些信息包括应该从何处发出该包的信息。
*inboundpacket —— 分组协议无关的表示从设备发送到控制器的包。这使控制器可以被动的通过PacketIns提供报文给Provider和应用程序按需使用，例如主机跟踪，链路检测功能。
*/
@Override
public Collection<PiPacketOperation> mapOutboundPacket(OutboundPacket packet)
throws PiInterpreterException {
TrafficTreatment treatment = packet.treatment();
//这里的treatment()是Returns how the outbound packet should be treated.注意，这里是引用的
// Packet-out in main.p4 supports only setting the output port,
// i.e. we only understand OUTPUT instructions.
List<OutputInstruction> outInstructions = treatment
.allInstructions()
.stream()
.filter(i -> i.type().equals(OUTPUT))
.map(i -> (OutputInstruction) i)
.collect(toList());
if (treatment.allInstructions().size() != outInstructions.size()) {
// There are other instructions that are not of type OUTPUT.
throw new PiInterpreterException("Treatment not supported: " + treatment);
}
ImmutableList.Builder<PiPacketOperation> builder = ImmutableList.builder();
for (OutputInstruction outInst : outInstructions) {
if (outInst.port().isLogical() && !outInst.port().equals(FLOOD)) {
throw new PiInterpreterException(format(
"Packet-out on logical port '%s' not supported",
outInst.port()));
} else if (outInst.port().equals(FLOOD)) {
// To emulate flooding, we create a packet-out operation for
// each switch port.
final DeviceService deviceService = handler().get(DeviceService.class);
for (Port port : deviceService.getPorts(packet.sendThrough())) {
builder.add(buildPacketOut(packet.data(), port.number().toLong()));
}
} else {
// Create only one packet-out for the given OUTPUT instruction.
builder.add(buildPacketOut(packet.data(), outInst.port().toLong()));
}
}
return builder.build();
}
/**
* Builds a pipeconf-specific packet-out instance with the given payload and
* egress port.
*
* @param pktData packet payload
* @param portNumber egress port
* @return packet-out
* @throws PiInterpreterException if packet-out cannot be built
*/
private PiPacketOperation buildPacketOut(ByteBuffer pktData, long portNumber)
throws PiInterpreterException {
// Make sure port number can fit in v1model port metadata bitwidth.
//这里提到了BIG_DIAN，这是字符在内存中的存放顺序，这个问题和鸡蛋应该朝哪个方向敲开差不多。。。
final ImmutableByteSequence portBytes;
try {
portBytes = copyFrom(portNumber).fit(V1MODEL_PORT_BITWIDTH);
} catch (ImmutableByteSequence.ByteSequenceTrimException e) {
throw new PiInterpreterException(format(
"Port number %d too big, %s", portNumber, e.getMessage()));
}
// Create metadata instance for egress port.
// *** TODO EXERCISE 4: modify metadata names to match P4 program
// ---- START SOLUTION ----
final String outPortMetadataName = "ADD HERE METADATA NAME FOR THE EGRESS PORT";
// ---- END SOLUTION ----
final PiPacketMetadata outPortMetadata = PiPacketMetadata.builder()
.withId(PiPacketMetadataId.of(outPortMetadataName))
.withValue(portBytes)
.build();
// Build packet out.
return PiPacketOperation.builder()
.withType(PACKET_OUT)
.withData(copyFrom(pktData))
.withMetadata(outPortMetadata)
.build();
}
/**
* Returns an ONS InboundPacket equivalent to the given pipeconf-specific
* packet-in operation.
*
* @param packetIn packet operation
* @param deviceId ID of the device that originated the packet-in
* @return inbound packet
* @throws PiInterpreterException if the packet operation cannot be mapped
* to an inbound packet
*/
@Override
public InboundPacket mapInboundPacket(PiPacketOperation packetIn, DeviceId deviceId)
throws PiInterpreterException {
// Find the ingress_port metadata.
// *** TODO EXERCISE 4: modify metadata names to match P4Info
// ---- START SOLUTION ----
final String inportMetadataName = "ADD HERE METADATA NAME FOR THE INGRESS PORT";
// ---- END SOLUTION ----
Optional<PiPacketMetadata> inportMetadata = packetIn.metadatas()
.stream()
.filter(meta -> meta.id().id().equals(inportMetadataName))
.findFirst();
if (!inportMetadata.isPresent()) {
throw new PiInterpreterException(format(
"Missing metadata '%s' in packet-in received from '%s': %s",
inportMetadataName, deviceId, packetIn));
}
// Build ONOS InboundPacket instance with the given ingress port.
// 1. Parse packet-in object into Ethernet packet instance.
final byte[] payloadBytes = packetIn.data().asArray();
final ByteBuffer rawData = ByteBuffer.wrap(payloadBytes);
final Ethernet ethPkt;
try {
ethPkt = Ethernet.deserializer().deserialize(
payloadBytes, 0, packetIn.data().size());
} catch (DeserializationException dex) {
throw new PiInterpreterException(dex.getMessage());
}
// 2. Get ingress port
final ImmutableByteSequence portBytes = inportMetadata.get().value();
final short portNum = portBytes.asReadOnlyBuffer().getShort();
final ConnectPoint receivedFrom = new ConnectPoint(
deviceId, PortNumber.portNumber(portNum));
return new DefaultInboundPacket(receivedFrom, ethPkt, rawData);
}
@Override
public Optional<Integer> mapLogicalPortNumber(PortNumber port) {
if (CONTROLLER.equals(port)) {
return Optional.of(CPU_PORT_ID);
} else {
return Optional.empty();
}
}
@Override
public Optional<PiMatchFieldId> mapCriterionType(Criterion.Type type) {
if (CRITERION_MAP.containsKey(type)) {
return Optional.of(PiMatchFieldId.of(CRITERION_MAP.get(type)));
} else {
return Optional.empty();
}
}
@Override
public PiAction mapTreatment(TrafficTreatment treatment, PiTableId piTableId)
throws PiInterpreterException {
throw new PiInterpreterException("Treatment mapping not supported");
}
@Override
public Optional<PiTableId> mapFlowRuleTableId(int flowRuleTableId) {
return Optional.empty();
}
}
PipeLinerImpl
/*
* Copyright 2019-present Open Networking Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ngsdn.tutorial.pipeconf;
import org.onosproject.net.DeviceId;
import org.onosproject.net.PortNumber;
import org.onosproject.net.behaviour.NextGroup;
import org.onosproject.net.behaviour.Pipeliner;
import org.onosproject.net.behaviour.PipelinerContext;
import org.onosproject.net.driver.AbstractHandlerBehaviour;
import org.onosproject.net.flow.DefaultFlowRule;
import org.onosproject.net.flow.DefaultTrafficTreatment;
import org.onosproject.net.flow.FlowRule;
import org.onosproject.net.flow.FlowRuleService;
import org.onosproject.net.flow.instructions.Instructions;
import org.onosproject.net.flowobjective.FilteringObjective;
import org.onosproject.net.flowobjective.ForwardingObjective;
import org.onosproject.net.flowobjective.NextObjective;
import org.onosproject.net.flowobjective.ObjectiveError;
import org.onosproject.net.group.GroupDescription;
import org.onosproject.net.group.GroupService;
import org.onosproject.net.pi.model.PiActionId;
import org.onosproject.net.pi.model.PiTableId;
import org.onosproject.net.pi.runtime.PiAction;
import org.onosproject.ngsdn.tutorial.common.Utils;
import org.slf4j.Logger;
import java.util.Collections;
import java.util.List;
import static org.onosproject.net.flow.instructions.Instruction.Type.OUTPUT;
import static org.onosproject.ngsdn.tutorial.AppConstants.CPU_CLONE_SESSION_ID;
import static org.slf4j.LoggerFactory.getLogger;
/**
* Pipeliner implementation that maps all forwarding objectives to the ACL
* table. All other types of objectives are not supported.
*/
public class PipelinerImpl extends AbstractHandlerBehaviour implements Pipeliner {
// From the P4Info file
private static final String ACL_TABLE = "IngressPipeImpl.acl_table";
private static final String CLONE_TO_CPU = "IngressPipeImpl.clone_to_cpu";
private final Logger log = getLogger(getClass());
private FlowRuleService flowRuleService;
//服务，用于向环境中注入流规则，并获取环境中已经存在的流规则的信息。这实现了分布式权威流表的语义，其中流规则的主副本位于控制器中，设备只持有“缓存”副本。
private GroupService groupService; //这里似乎没有用到。。
//在设备中创建/更新/删除“组”的服务。流条目可以指向设备中定义的“组”，该“组”允许表示其他转发方法，如负载平衡或不同端口组之间的故障转移或组播到指定的所有端口。“group”还可以用于对不同流的通用操作进行分组，因此在某些场景中，只需要为所有引用流条目修改一个组条目，而不是修改所有的组条目。这实现了分布式权威组存储的语义，其中组的主副本位于控制器中，设备只持有“缓存”副本。
private DeviceId deviceId;
@Override
public void init(DeviceId deviceId, PipelinerContext context) {
this.deviceId = deviceId;
this.flowRuleService = context.directory().get(FlowRuleService.class);
this.groupService = context.directory().get(GroupService.class);
}
@Override
public void filter(FilteringObjective obj) {
obj.context().ifPresent(c -> c.onError(obj, ObjectiveError.UNSUPPORTED));
}
@Override
public void forward(ForwardingObjective obj) {
if (obj.treatment() == null) {
obj.context().ifPresent(c -> c.onError(obj, ObjectiveError.UNSUPPORTED));
}
// Whether this objective specifies an OUTPUT:CONTROLLER instruction.
final boolean hasCloneToCpuAction = obj.treatment()
.allInstructions().stream()
.filter(i -> i.type().equals(OUTPUT))
.map(i -> (Instructions.OutputInstruction) i)
.anyMatch(i -> i.port().equals(PortNumber.CONTROLLER));
if (!hasCloneToCpuAction) {
// We support only objectives for clone to CPU behaviours (e.g. for
// host and link discovery)
obj.context().ifPresent(c -> c.onError(obj, ObjectiveError.UNSUPPORTED));
}
// Create an equivalent FlowRule with same selector and clone_to_cpu action.
final PiAction cloneToCpuAction = PiAction.builder()
.withId(PiActionId.of(CLONE_TO_CPU))
.build();
final FlowRule.Builder ruleBuilder = DefaultFlowRule.builder()
.forTable(PiTableId.of(ACL_TABLE))
.forDevice(deviceId)
.withSelector(obj.selector())
.fromApp(obj.appId())
.withPriority(obj.priority())
.withTreatment(DefaultTrafficTreatment.builder()
.piTableAction(cloneToCpuAction).build());
if (obj.permanent()) {
ruleBuilder.makePermanent();
} else {
ruleBuilder.makeTemporary(obj.timeout());
}
final GroupDescription cloneGroup = Utils.buildCloneGroup(
obj.appId(),
deviceId,
CPU_CLONE_SESSION_ID,
// Ports where to clone the packet.
// Just controller in this case.
Collections.singleton(PortNumber.CONTROLLER));
switch (obj.op()) {
case ADD:
flowRuleService.applyFlowRules(ruleBuilder.build());
groupService.addGroup(cloneGroup);
break;
case REMOVE:
flowRuleService.removeFlowRules(ruleBuilder.build());
// Do not remove the clone group as other flow rules might be
// pointing to it.
break;
default:
log.warn("Unknown operation {}", obj.op());
}
obj.context().ifPresent(c -> c.onSuccess(obj));
}
@Override
public void next(NextObjective obj) {
obj.context().ifPresent(c -> c.onError(obj, ObjectiveError.UNSUPPORTED));
}
@Override
public List<String> getNextMappings(NextGroup nextGroup) {
// We do not use nextObjectives or groups.
return Collections.emptyList();
}
}
make restart
make app-build
make app-reload
make netcfg
然后你就可以看到这一张图片了。。。数据包因为可以进行传输，所以有了链路。。。
These flow rules are the result of the translation of flow objectives generated by the hostprovider and lldpprovider built-in apps.
以上这些所有的基本功能都是由LLDPprovider这个应用和hostProvider才能够实现的。。。。，并且这一切都是基于P4交换机中的那些代码帮助.
/*
* Copyright 2019-present Open Networking Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <core.p4>
#include <v1model.p4>
// CPU_PORT specifies the P4 port number associated to controller packet-in and
// packet-out. All packets forwarded via this port will be delivered to the
// controller as P4Runtime PacketIn messages. Similarly, PacketOut messages from
// the controller will be seen by the P4 pipeline as coming from the CPU_PORT.
#define CPU_PORT 255
// CPU_CLONE_SESSION_ID specifies the mirroring session for packets to be cloned
// to the CPU port. Packets associated with this session ID will be cloned to
// the CPU_PORT as well as being transmitted via their egress port (set by the
// bridging/routing/acl table). For cloning to work, the P4Runtime controller
// needs first to insert a CloneSessionEntry that maps this session ID to the
// CPU_PORT.
#define CPU_CLONE_SESSION_ID 99
// Maximum number of hops supported when using SRv6.
// Required for Exercise 7.
#define SRV6_MAX_HOPS 4
typedef bit<9> port_num_t;
typedef bit<48> mac_addr_t;
typedef bit<16> mcast_group_id_t;
typedef bit<32> ipv4_addr_t;
typedef bit<128> ipv6_addr_t;
typedef bit<16> l4_port_t;
const bit<16> ETHERTYPE_IPV4 = 0x0800;
const bit<16> ETHERTYPE_IPV6 = 0x86dd;
const bit<8> IP_PROTO_ICMP = 1;
const bit<8> IP_PROTO_TCP = 6;
const bit<8> IP_PROTO_UDP = 17;
const bit<8> IP_PROTO_SRV6 = 43;
const bit<8> IP_PROTO_ICMPV6 = 58;
const mac_addr_t IPV6_MCAST_01 = 0x33_33_00_00_00_01;
const bit<8> ICMP6_TYPE_NS = 135;
const bit<8> ICMP6_TYPE_NA = 136;
const bit<8> NDP_OPT_TARGET_LL_ADDR = 2;
const bit<32> NDP_FLAG_ROUTER = 0x80000000;
const bit<32> NDP_FLAG_SOLICITED = 0x40000000;
const bit<32> NDP_FLAG_OVERRIDE = 0x20000000;
//------------------------------------------------------------------------------
// HEADER DEFINITIONS
//------------------------------------------------------------------------------
header ethernet_t {
mac_addr_t dst_addr;
mac_addr_t src_addr;
bit<16> ether_type;
}
header ipv4_t {
bit<4> version;
bit<4> ihl;
bit<6> dscp;
bit<2> ecn;
bit<16> total_len;
bit<16> identification;
bit<3> flags;
bit<13> frag_offset;
bit<8> ttl;
bit<8> protocol;
bit<16> hdr_checksum;
bit<32> src_addr;
bit<32> dst_addr;
}
header ipv6_t {
bit<4> version;
bit<8> traffic_class;
bit<20> flow_label;
bit<16> payload_len;
bit<8> next_hdr;
bit<8> hop_limit;
bit<128> src_addr;
bit<128> dst_addr;
}
header srv6h_t {
bit<8> next_hdr;
bit<8> hdr_ext_len;
bit<8> routing_type;
bit<8> segment_left;
bit<8> last_entry;
bit<8> flags;
bit<16> tag;
}
header srv6_list_t {
bit<128> segment_id;
}
header tcp_t {
bit<16> src_port;
bit<16> dst_port;
bit<32> seq_no;
bit<32> ack_no;
bit<4> data_offset;
bit<3> res;
bit<3> ecn;
bit<6> ctrl;
bit<16> window;
bit<16> checksum;
bit<16> urgent_ptr;
}
header udp_t {
bit<16> src_port;
bit<16> dst_port;
bit<16> len;
bit<16> checksum;
}
header icmp_t {
bit<8> type;
bit<8> icmp_code;
bit<16> checksum;
bit<16> identifier;
bit<16> sequence_number;
bit<64> timestamp;
}
header icmpv6_t {
bit<8> type;
bit<8> code;
bit<16> checksum;
}
header ndp_t {
bit<32> flags;
ipv6_addr_t target_ipv6_addr;
// NDP option.
bit<8> type;
bit<8> length;
bit<48> target_mac_addr;
}
// Packet-in header. Prepended to packets sent to the CPU_PORT and used by the
// P4Runtime server (Stratum) to populate the PacketIn message metadata fields.
// Here we use it to carry the original ingress port where the packet was
// received.
@controller_header("packet_in")
header cpu_in_header_t {
port_num_t ingress_port;
bit<7> _pad;
}
// Packet-out header. Prepended to packets received from the CPU_PORT. Fields of
// this header are populated by the P4Runtime server based on the P4Runtime
// PacketOut metadata fields. Here we use it to inform the P4 pipeline on which
// port this packet-out should be transmitted.
@controller_header("packet_out")
header cpu_out_header_t {
port_num_t egress_port;
bit<7> _pad;
}
struct parsed_headers_t {
cpu_out_header_t cpu_out;
cpu_in_header_t cpu_in;
ethernet_t ethernet;
ipv4_t ipv4;
ipv6_t ipv6;
srv6h_t srv6h;
srv6_list_t[SRV6_MAX_HOPS] srv6_list;
tcp_t tcp;
udp_t udp;
icmp_t icmp;
icmpv6_t icmpv6;
ndp_t ndp;
}
struct local_metadata_t {
l4_port_t l4_src_port;
l4_port_t l4_dst_port;
bool is_multicast;
ipv6_addr_t next_srv6_sid;
bit<8> ip_proto;
bit<8> icmp_type;
}
//------------------------------------------------------------------------------
// INGRESS PIPELINE
//------------------------------------------------------------------------------
parser ParserImpl (packet_in packet,
out parsed_headers_t hdr,
inout local_metadata_t local_metadata,
inout standard_metadata_t standard_metadata)
{
state start {
transition select(standard_metadata.ingress_port) {
CPU_PORT: parse_packet_out;
default: parse_ethernet;
}
}
state parse_packet_out {
packet.extract(hdr.cpu_out);
transition parse_ethernet;
}
state parse_ethernet {
packet.extract(hdr.ethernet);
transition select(hdr.ethernet.ether_type){
ETHERTYPE_IPV4: parse_ipv4;
ETHERTYPE_IPV6: parse_ipv6;
default: accept;
}
}
state parse_ipv4 {
packet.extract(hdr.ipv4);
local_metadata.ip_proto = hdr.ipv4.protocol;
transition select(hdr.ipv4.protocol) {
IP_PROTO_TCP: parse_tcp;
IP_PROTO_UDP: parse_udp;
IP_PROTO_ICMP: parse_icmp;
default: accept;
}
}
state parse_ipv6 {
packet.extract(hdr.ipv6);
local_metadata.ip_proto = hdr.ipv6.next_hdr;
transition select(hdr.ipv6.next_hdr) {
IP_PROTO_TCP: parse_tcp;
IP_PROTO_UDP: parse_udp;
IP_PROTO_ICMPV6: parse_icmpv6;
IP_PROTO_SRV6: parse_srv6;
default: accept;
}
}
state parse_tcp {
packet.extract(hdr.tcp);
local_metadata.l4_src_port = hdr.tcp.src_port;
local_metadata.l4_dst_port = hdr.tcp.dst_port;
transition accept;
}
state parse_udp {
packet.extract(hdr.udp);
local_metadata.l4_src_port = hdr.udp.src_port;
local_metadata.l4_dst_port = hdr.udp.dst_port;
transition accept;
}
state parse_icmp {
packet.extract(hdr.icmp);
local_metadata.icmp_type = hdr.icmp.type;
transition accept;
}
state parse_icmpv6 {
packet.extract(hdr.icmpv6);
local_metadata.icmp_type = hdr.icmpv6.type;
transition select(hdr.icmpv6.type) {
ICMP6_TYPE_NS: parse_ndp;
ICMP6_TYPE_NA: parse_ndp;
default: accept;
}
}
state parse_ndp {
packet.extract(hdr.ndp);
transition accept;
}
state parse_srv6 {
packet.extract(hdr.srv6h);
transition parse_srv6_list;
}
state parse_srv6_list {
packet.extract(hdr.srv6_list.next);
bool next_segment = (bit<32>)hdr.srv6h.segment_left - 1 == (bit<32>)hdr.srv6_list.lastIndex;
transition select(next_segment) {
true: mark_current_srv6;
default: check_last_srv6;
}
}
state mark_current_srv6 {
local_metadata.next_srv6_sid = hdr.srv6_list.last.segment_id;
transition check_last_srv6;
}
state check_last_srv6 {
// working with bit<8> and int<32> which cannot be cast directly; using
// bit<32> as common intermediate type for comparision
bool last_segment = (bit<32>)hdr.srv6h.last_entry == (bit<32>)hdr.srv6_list.lastIndex;
transition select(last_segment) {
true: parse_srv6_next_hdr;
false: parse_srv6_list;
}
}
state parse_srv6_next_hdr {
transition select(hdr.srv6h.next_hdr) {
IP_PROTO_TCP: parse_tcp;
IP_PROTO_UDP: parse_udp;
IP_PROTO_ICMPV6: parse_icmpv6;
default: accept;
}
}
}
control VerifyChecksumImpl(inout parsed_headers_t hdr,
inout local_metadata_t meta)
{
// Not used here. We assume all packets have valid checksum, if not, we let
// the end hosts detect errors.
apply { /* EMPTY */ }
}
control IngressPipeImpl (inout parsed_headers_t hdr,
inout local_metadata_t local_metadata,
inout standard_metadata_t standard_metadata) {
// Drop action shared by many tables.
action drop() {
mark_to_drop(standard_metadata);
}
// *** L2 BRIDGING
//
// Here we define tables to forward packets based on their Ethernet
// destination address. There are two types of L2 entries that we
// need to support:
//
// 1. Unicast entries: which will be filled in by the control plane when the
// location (port) of new hosts is learned.
// 2. Broadcast/multicast entries: used replicate NDP Neighbor Solicitation
// (NS) messages to all host-facing ports;
//
// For (2), unlike ARP messages in IPv4 which are broadcasted to Ethernet
// destination address FF:FF:FF:FF:FF:FF, NDP messages are sent to special
// Ethernet addresses specified by RFC2464. These addresses are prefixed
// with 33:33 and the last four octets are the last four octets of the IPv6
// destination multicast address. The most straightforward way of matching
// on such IPv6 broadcast/multicast packets, without digging in the details
// of RFC2464, is to use a ternary match on 33:33:**:**:**:**, where * means
// "don't care".
//
// For this reason, our solution defines two tables. One that matches in an
// exact fashion (easier to scale on switch ASIC memory) and one that uses
// ternary matching (which requires more expensive TCAM memories, usually
// much smaller).
// --- l2_exact_table (for unicast entries) --------------------------------
action set_egress_port(port_num_t port_num) {
standard_metadata.egress_spec = port_num;
}
table l2_exact_table {
key = {
hdr.ethernet.dst_addr: exact;
}
actions = {
set_egress_port;
@defaultonly drop;
}
const default_action = drop;
// The @name annotation is used here to provide a name to this table
// counter, as it will be needed by the compiler to generate the
// corresponding P4Info entity.
@name("l2_exact_table_counter")
counters = direct_counter(CounterType.packets_and_bytes);
}
// --- l2_ternary_table (for broadcast/multicast entries) ------------------
action set_multicast_group(mcast_group_id_t gid) {
// gid will be used by the Packet Replication Engine (PRE) in the
// Traffic Manager--located right after the ingress pipeline, to
// replicate a packet to multiple egress ports, specified by the control
// plane by means of P4Runtime MulticastGroupEntry messages.
standard_metadata.mcast_grp = gid;
local_metadata.is_multicast = true;
}
table l2_ternary_table {
key = {
hdr.ethernet.dst_addr: ternary;
}
actions = {
set_multicast_group;
@defaultonly drop;
}
const default_action = drop;
@name("l2_ternary_table_counter")
counters = direct_counter(CounterType.packets_and_bytes);
}
// *** TODO EXERCISE 5 (IPV6 ROUTING)
//
// 1. Create a table to to handle NDP messages to resolve the MAC address of
// switch. This table should:
// - match on hdr.ndp.target_ipv6_addr (exact match)
// - provide action "ndp_ns_to_na" (look in snippets.p4)
// - default_action should be "NoAction"
//
// 2. Create table to handle IPv6 routing. Create a L2 my station table (hit
// when Ethernet destination address is the switch address). This table
// should not do anything to the packet (i.e., NoAction), but the control
// block below should use the result (table.hit) to decide how to process
// the packet.
//
// 3. Create a table for IPv6 routing. An action selector should be use to
// pick a next hop MAC address according to a hash of packet header
// fields (IPv6 source/destination address and the flow label). Look in
// snippets.p4 for an example of an action selector and table using it.
//
// You can name your tables whatever you like. You will need to fill
// the name in elsewhere in this exercise.
// *** TODO EXERCISE 6 (SRV6)
//
// Implement tables to provide SRV6 logic.
// *** ACL
//
// Provides ways to override a previous forwarding decision, for example
// requiring that a packet is cloned/sent to the CPU, or dropped.
//
// We use this table to clone all NDP packets to the control plane, so to
// enable host discovery. When the location of a new host is discovered, the
// controller is expected to update the L2 and L3 tables with the
// corresponding bridging and routing entries.
action send_to_cpu() {
standard_metadata.egress_spec = CPU_PORT;
}
action clone_to_cpu() {
// Cloning is achieved by using a v1model-specific primitive. Here we
// set the type of clone operation (ingress-to-egress pipeline), the
// clone session ID (the CPU one), and the metadata fields we want to
// preserve for the cloned packet replica.
clone3(CloneType.I2E, CPU_CLONE_SESSION_ID, { standard_metadata.ingress_port });
}
table acl_table {
//这里没有entries，不知道是在哪里加的。。
key = {
standard_metadata.ingress_port: ternary;
hdr.ethernet.dst_addr: ternary;
hdr.ethernet.src_addr: ternary;
hdr.ethernet.ether_type: ternary;
local_metadata.ip_proto: ternary;
local_metadata.icmp_type: ternary;
local_metadata.l4_src_port: ternary;
local_metadata.l4_dst_port: ternary;
}
actions = {
send_to_cpu;
clone_to_cpu;
drop;
}
@name("acl_table_counter")
counters = direct_counter(CounterType.packets_and_bytes);
}
apply {
if (hdr.cpu_out.isValid()) {
// *** TODO EXERCISE 4
// Implement logic such that if this is a packet-out from the
// controller:
// 1. Set the packet egress port to that found in the cpu_out header
// 2. Remove (set invalid) the cpu_out header
// 3. Exit the pipeline here (no need to go through other tables
standard_metadata.egress_spec = hdr.cpu_out.egress_port;
hdr.cpu_out.setInvalid();
exit;
}
bool do_l3_l2 = true;
if (hdr.icmpv6.isValid() && hdr.icmpv6.type == ICMP6_TYPE_NS) {
// *** TODO EXERCISE 5
// Insert logic to handle NDP messages to resolve the MAC address of the
// switch. You should apply the NDP reply table created before.
// If this is an NDP NS packet, i.e., if a matching entry is found,
// unset the "do_l3_l2" flag to skip the L3 and L2 tables, as the
// "ndp_ns_to_na" action already set an egress port.
}
if (do_l3_l2) {
// *** TODO EXERCISE 5
// Insert logic to match the My Station table and upon hit, the
// routing table. You should also add a conditional to drop the
// packet if the hop_limit reaches 0.
// *** TODO EXERCISE 6
// Insert logic to match the SRv6 My SID and Transit tables as well
// as logic to perform PSP behavior. HINT: This logic belongs
// somewhere between checking the switch's my station table and
// applying the routing table.
// L2 bridging logic. Apply the exact table first...
if (!l2_exact_table.apply().hit) {
// ...if an entry is NOT found, apply the ternary one in case
// this is a multicast/broadcast NDP NS packet.
l2_ternary_table.apply();
}
}
// Lastly, apply the ACL table.
acl_table.apply();
}
}
control EgressPipeImpl (inout parsed_headers_t hdr,
inout local_metadata_t local_metadata,
inout standard_metadata_t standard_metadata) {
apply {
if (standard_metadata.egress_port == CPU_PORT) {
// *** TODO EXERCISE 4
// Implement logic such that if the packet is to be forwarded to the
// CPU port, e.g., if in ingress we matched on the ACL table with
// action send/clone_to_cpu...
// 1. Set cpu_in header as valid
// 2. Set the cpu_in.ingress_port field to the original packet's
// ingress port (standard_metadata.ingress_port).
hdr.cpu_in.setValid();
hdr.cpu_in.ingress_port = standard_metadata.ingress_port;
exit;
}
// If this is a multicast packet (flag set by l2_ternary_table), make
// sure we are not replicating the packet on the same port where it was
// received. This is useful to avoid broadcasting NDP requests on the
// ingress port.
if (local_metadata.is_multicast == true &&
standard_metadata.ingress_port == standard_metadata.egress_port) {
mark_to_drop(standard_metadata);
}
}
}
control ComputeChecksumImpl(inout parsed_headers_t hdr,
inout local_metadata_t local_metadata)
{
apply {
// The following is used to update the ICMPv6 checksum of NDP
// NA packets generated by the ndp reply table in the ingress pipeline.
// This function is executed only if the NDP header is present.
update_checksum(hdr.ndp.isValid(),
{
hdr.ipv6.src_addr,
hdr.ipv6.dst_addr,
hdr.ipv6.payload_len,
8w0,
hdr.ipv6.next_hdr,
hdr.icmpv6.type,
hdr.icmpv6.code,
hdr.ndp.flags,
hdr.ndp.target_ipv6_addr,
hdr.ndp.type,
hdr.ndp.length,
hdr.ndp.target_mac_addr
},
hdr.icmpv6.checksum,
HashAlgorithm.csum16
);
}
}
control DeparserImpl(packet_out packet, in parsed_headers_t hdr) {
apply {
packet.emit(hdr.cpu_in);
packet.emit(hdr.ethernet);
packet.emit(hdr.ipv4);
packet.emit(hdr.ipv6);
packet.emit(hdr.srv6h);
packet.emit(hdr.srv6_list);
packet.emit(hdr.tcp);
packet.emit(hdr.udp);
packet.emit(hdr.icmp);
packet.emit(hdr.icmpv6);
packet.emit(hdr.ndp);
}
}
V1Switch(
ParserImpl(),
VerifyChecksumImpl(),
IngressPipeImpl(),
EgressPipeImpl(),
ComputeChecksumImpl(),
DeparserImpl()
) main;
妈的，无法理解，只能继续看了QAQ
/*
* Copyright 2019-present Open Networking Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.ngsdn.tutorial;
import com.google.common.collect.Lists;
import org.onlab.packet.Ip6Address;
import org.onlab.packet.Ip6Prefix;
import org.onlab.packet.IpAddress;
import org.onlab.packet.IpPrefix;
import org.onlab.packet.MacAddress;
import org.onlab.util.ItemNotFoundException;
import org.onosproject.core.ApplicationId;
import org.onosproject.mastership.MastershipService;
import org.onosproject.net.Device;
import org.onosproject.net.DeviceId;
import org.onosproject.net.Host;
import org.onosproject.net.Link;
import org.onosproject.net.PortNumber;
import org.onosproject.net.config.NetworkConfigService;
import org.onosproject.net.device.DeviceEvent;
import org.onosproject.net.device.DeviceListener;
import org.onosproject.net.device.DeviceService;
import org.onosproject.net.flow.FlowRule;
import org.onosproject.net.flow.FlowRuleService;
import org.onosproject.net.flow.criteria.PiCriterion;
import org.onosproject.net.group.GroupDescription;
import org.onosproject.net.group.GroupService;
import org.onosproject.net.host.HostEvent;
import org.onosproject.net.host.HostListener;
import org.onosproject.net.host.HostService;
import org.onosproject.net.host.InterfaceIpAddress;
import org.onosproject.net.intf.Interface;
import org.onosproject.net.intf.InterfaceService;
import org.onosproject.net.link.LinkEvent;
import org.onosproject.net.link.LinkListener;
import org.onosproject.net.link.LinkService;
import org.onosproject.net.pi.model.PiActionId;
import org.onosproject.net.pi.model.PiActionParamId;
import org.onosproject.net.pi.model.PiMatchFieldId;
import org.onosproject.net.pi.runtime.PiAction;
import org.onosproject.net.pi.runtime.PiActionParam;
import org.onosproject.net.pi.runtime.PiActionProfileGroupId;
import org.onosproject.net.pi.runtime.PiTableAction;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
import org.osgi.service.component.annotations.Reference;
import org.osgi.service.component.annotations.ReferenceCardinality;
import org.onosproject.ngsdn.tutorial.common.FabricDeviceConfig;
import org.onosproject.ngsdn.tutorial.common.Utils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import static com.google.common.collect.Streams.stream;
import static org.onosproject.ngsdn.tutorial.AppConstants.INITIAL_SETUP_DELAY;
/**
* App component that configures devices to provide IPv6 routing capabilities
* across the whole fabric.
*/
@Component(
immediate = true,
// *** TODO EXERCISE 5
// set to true when ready
enabled = true
)
public class Ipv6RoutingComponent {
//老三样的log
private static final Logger log = LoggerFactory.getLogger(Ipv6RoutingComponent.class);
private static final int DEFAULT_ECMP_GROUP_ID = 0xec3b0000;
private static final long GROUP_INSERT_DELAY_MILLIS = 200;
private final HostListener hostListener = new InternalHostListener();
private final LinkListener linkListener = new InternalLinkListener();
private final DeviceListener deviceListener = new InternalDeviceListener();
private ApplicationId appId;
//--------------------------------------------------------------------------
// ONOS CORE SERVICE BINDING
//
// These variables are set by the Karaf runtime environment before calling
// the activate() method.
//--------------------------------------------------------------------------
@Reference(cardinality = ReferenceCardinality.MANDATORY)
private FlowRuleService flowRuleService;
@Reference(cardinality = ReferenceCardinality.MANDATORY)
private HostService hostService;
@Reference(cardinality = ReferenceCardinality.MANDATORY)
private MastershipService mastershipService;
@Reference(cardinality = ReferenceCardinality.MANDATORY)
private GroupService groupService;
@Reference(cardinality = ReferenceCardinality.MANDATORY)
private DeviceService deviceService;
@Reference(cardinality = ReferenceCardinality.MANDATORY)
private NetworkConfigService networkConfigService;
@Reference(cardinality = ReferenceCardinality.MANDATORY)
private InterfaceService interfaceService;
@Reference(cardinality = ReferenceCardinality.MANDATORY)
private LinkService linkService;
@Reference(cardinality = ReferenceCardinality.MANDATORY)
private MainComponent mainComponent;
//--------------------------------------------------------------------------
// COMPONENT ACTIVATION.
//
// When loading/unloading the app the Karaf runtime environment will call
// activate()/deactivate().
//--------------------------------------------------------------------------
@Activate
protected void activate() {
appId = mainComponent.getAppId();
hostService.addListener(hostListener);
linkService.addListener(linkListener);
deviceService.addListener(deviceListener);
// Schedule set up for all devices.
mainComponent.scheduleTask(this::setUpAllDevices, INITIAL_SETUP_DELAY);
log.info("Started");
}
@Deactivate
protected void deactivate() {
hostService.removeListener(hostListener);
linkService.removeListener(linkListener);
deviceService.removeListener(deviceListener);
log.info("Stopped");
}
//--------------------------------------------------------------------------
// METHODS TO COMPLETE.
//
// Complete the implementation wherever you see TODO.
//--------------------------------------------------------------------------
/**
* Sets up the "My Station" table for the given device using the
* myStationMac address found in the config.
* <p>
* This method will be called at component activation for each device
* (switch) known by ONOS, and every time a new device-added event is
* captured by the InternalDeviceListener defined below.
*
* @param deviceId the device ID
*/
private void setUpMyStationTable(DeviceId deviceId) {
log.info("Adding My Station rules to {}...", deviceId);
final MacAddress myStationMac = getMyStationMac(deviceId);
// HINT: in our solution, the My Station table matches on the *ethernet
// destination* and there is only one action called *NoAction*, which is
// used as an indication of "table hit" in the control block.
// *** TODO EXERCISE 5
// Modify P4Runtime entity names to match content of P4Info file (look
// for the fully qualified name of tables, match fields, and actions.
// ---- START SOLUTION ----
final String tableId = "MODIFY ME";
final PiCriterion match = PiCriterion.builder()
.matchExact(
PiMatchFieldId.of("MODIFY ME"),
myStationMac.toBytes())
.build();
// Creates an action which do *NoAction* when hit.
final PiTableAction action = PiAction.builder()
.withId(PiActionId.of("MODIFY ME"))
.build();
// ---- END SOLUTION ----
final FlowRule myStationRule = Utils.buildFlowRule(
deviceId, appId, tableId, match, action);
flowRuleService.applyFlowRules(myStationRule);
}
/**
* Creates an ONOS SELECT group for the routing table to provide ECMP
* forwarding for the given collection of next hop MAC addresses. ONOS
* SELECT groups are equivalent to P4Runtime action selector groups.
* <p>
* This method will be called by the routing policy methods below to insert
* groups in the L3 table
*
* @param nextHopMacs the collection of mac addresses of next hops
* @param deviceId the device where the group will be installed
* @return a SELECT group
*/
private GroupDescription createNextHopGroup(int groupId,
Collection<MacAddress> nextHopMacs,
DeviceId deviceId) {
String actionProfileId = "IngressPipeImpl.ecmp_selector";
final List<PiAction> actions = Lists.newArrayList();
// Build one "set next hop" action for each next hop
// *** TODO EXERCISE 5
// Modify P4Runtime entity names to match content of P4Info file (look
// for the fully qualified name of tables, match fields, and actions.
// ---- START SOLUTION ----
final String tableId = "MODIFY ME";
for (MacAddress nextHopMac : nextHopMacs) {
final PiAction action = PiAction.builder()
.withId(PiActionId.of("MODIFY ME"))
.withParameter(new PiActionParam(
// Action param name.
PiActionParamId.of("MODIFY ME"),
// Action param value.
nextHopMac.toBytes()))
.build();
actions.add(action);
}
// ---- END SOLUTION ----
return Utils.buildSelectGroup(
deviceId, tableId, actionProfileId, groupId, actions, appId);
}
/**
* Creates a routing flow rule that matches on the given IPv6 prefix and
* executes the given group ID (created before).
*
* @param deviceId the device where flow rule will be installed
* @param ip6Prefix the IPv6 prefix
* @param groupId the group ID
* @return a flow rule
*/
private FlowRule createRoutingRule(DeviceId deviceId, Ip6Prefix ip6Prefix,
int groupId) {
// *** TODO EXERCISE 5
// Modify P4Runtime entity names to match content of P4Info file (look
// for the fully qualified name of tables, match fields, and actions.
// ---- START SOLUTION ----
final String tableId = "MODIFY ME";
final PiCriterion match = PiCriterion.builder()
.matchLpm(
PiMatchFieldId.of("MODIFY ME"),
ip6Prefix.address().toOctets(),
ip6Prefix.prefixLength())
.build();
final PiTableAction action = PiActionProfileGroupId.of(groupId);
// ---- END SOLUTION ----
return Utils.buildFlowRule(
deviceId, appId, tableId, match, action);
}
/**
* Creates a flow rule for the L2 table mapping the given next hop MAC to
* the given output port.
* <p>
* This is called by the routing policy methods below to establish L2-based
* forwarding inside the fabric, e.g., when deviceId is a leaf switch and
* nextHopMac is the one of a spine switch.
*
* @param deviceId the device
* @param nexthopMac the next hop (destination) mac
* @param outPort the output port
*/
private FlowRule createL2NextHopRule(DeviceId deviceId, MacAddress nexthopMac,
PortNumber outPort) {
// *** TODO EXERCISE 5
// Modify P4Runtime entity names to match content of P4Info file (look
// for the fully qualified name of tables, match fields, and actions.
// ---- START SOLUTION ----
final String tableId = "MODIFY ME";
final PiCriterion match = PiCriterion.builder()
.matchExact(PiMatchFieldId.of("MODIFY ME"),
nexthopMac.toBytes())
.build();
final PiAction action = PiAction.builder()
.withId(PiActionId.of("MODIFY ME"))
.withParameter(new PiActionParam(
PiActionParamId.of("MODIFY ME"),
outPort.toLong()))
.build();
// ---- END SOLUTION ----
return Utils.buildFlowRule(
deviceId, appId, tableId, match, action);
}
//--------------------------------------------------------------------------
// EVENT LISTENERS
//
// Events are processed only if isRelevant() returns true.
//--------------------------------------------------------------------------
/**
* Listener of host events which triggers configuration of routing rules on
* the device where the host is attached.
*/
class InternalHostListener implements HostListener {
@Override
public boolean isRelevant(HostEvent event) {
switch (event.type()) {
case HOST_ADDED:
break;
case HOST_REMOVED:
case HOST_UPDATED:
case HOST_MOVED:
default:
// Ignore other events.
// Food for thoughts:
// how to support host moved/removed events?
return false;
}
// Process host event only if this controller instance is the master
// for the device where this host is attached.
final Host host = event.subject();
final DeviceId deviceId = host.location().deviceId();
return mastershipService.isLocalMaster(deviceId);
}
@Override
public void event(HostEvent event) {
Host host = event.subject();
DeviceId deviceId = host.location().deviceId();
mainComponent.getExecutorService().execute(() -> {
log.info("{} event! host={}, deviceId={}, port={}",
event.type(), host.id(), deviceId, host.location().port());
setUpHostRules(deviceId, host);
});
}
}
/**
* Listener of link events, which triggers configuration of routing rules to
* forward packets across the fabric, i.e. from leaves to spines and vice
* versa.
* <p>
* Reacting to link events instead of device ones, allows us to make sure
* all device are always configured with a topology view that includes all
* links, e.g. modifying an ECMP group as soon as a new link is added. The
* downside is that we might be configuring the same device twice for the
* same set of links/paths. However, the ONOS core treats these cases as a
* no-op when the device is already configured with the desired forwarding
* state (i.e. flows and groups)
*/
class InternalLinkListener implements LinkListener {
@Override
public boolean isRelevant(LinkEvent event) {
switch (event.type()) {
case LINK_ADDED:
break;
case LINK_UPDATED:
case LINK_REMOVED:
default:
return false;
}
DeviceId srcDev = event.subject().src().deviceId();
DeviceId dstDev = event.subject().dst().deviceId();
return mastershipService.isLocalMaster(srcDev) ||
mastershipService.isLocalMaster(dstDev);
}
@Override
public void event(LinkEvent event) {
DeviceId srcDev = event.subject().src().deviceId();
DeviceId dstDev = event.subject().dst().deviceId();
if (mastershipService.isLocalMaster(srcDev)) {
mainComponent.getExecutorService().execute(() -> {
log.info("{} event! Configuring {}... linkSrc={}, linkDst={}",
event.type(), srcDev, srcDev, dstDev);
setUpFabricRoutes(srcDev);
setUpL2NextHopRules(srcDev);
});
}
if (mastershipService.isLocalMaster(dstDev)) {
mainComponent.getExecutorService().execute(() -> {
log.info("{} event! Configuring {}... linkSrc={}, linkDst={}",
event.type(), dstDev, srcDev, dstDev);
setUpFabricRoutes(dstDev);
setUpL2NextHopRules(dstDev);
});
}
}
}
/**
* Listener of device events which triggers configuration of the My Station
* table.
*/
class InternalDeviceListener implements DeviceListener {
@Override
public boolean isRelevant(DeviceEvent event) {
switch (event.type()) {
case DEVICE_AVAILABILITY_CHANGED:
case DEVICE_ADDED:
break;
default:
return false;
}
// Process device event if this controller instance is the master
// for the device and the device is available.
DeviceId deviceId = event.subject().id();
return mastershipService.isLocalMaster(deviceId) &&
deviceService.isAvailable(event.subject().id());
}
@Override
public void event(DeviceEvent event) {
mainComponent.getExecutorService().execute(() -> {
DeviceId deviceId = event.subject().id();
log.info("{} event! device id={}", event.type(), deviceId);
setUpMyStationTable(deviceId);
});
}
}
//--------------------------------------------------------------------------
// ROUTING POLICY METHODS
//
// Called by event listeners, these methods implement the actual routing
// policy, responsible of computing paths and creating ECMP groups.
//--------------------------------------------------------------------------
/**
* Set up L2 nexthop rules of a device to providing forwarding inside the
* fabric, i.e. between leaf and spine switches.
*
* @param deviceId the device ID
*/
private void setUpL2NextHopRules(DeviceId deviceId) {
Set<Link> egressLinks = linkService.getDeviceEgressLinks(deviceId);
for (Link link : egressLinks) {
// For each other switch directly connected to this.
final DeviceId nextHopDevice = link.dst().deviceId();
// Get port of this device connecting to next hop.
final PortNumber outPort = link.src().port();
// Get next hop MAC address.
final MacAddress nextHopMac = getMyStationMac(nextHopDevice);
final FlowRule nextHopRule = createL2NextHopRule(
deviceId, nextHopMac, outPort);
flowRuleService.applyFlowRules(nextHopRule);
}
}
/**
* Sets up the given device with the necessary rules to route packets to the
* given host.
*
* @param deviceId deviceId the device ID
* @param host the host
*/
private void setUpHostRules(DeviceId deviceId, Host host) {
// Get all IPv6 addresses associated to this host. In this tutorial we
// use hosts with only 1 IPv6 address.
final Collection<Ip6Address> hostIpv6Addrs = host.ipAddresses().stream()
.filter(IpAddress::isIp6)
.map(IpAddress::getIp6Address)
.collect(Collectors.toSet());
if (hostIpv6Addrs.isEmpty()) {
// Ignore.
log.debug("No IPv6 addresses for host {}, ignore", host.id());
return;
} else {
log.info("Adding routes on {} for host {} [{}]",
deviceId, host.id(), hostIpv6Addrs);
}
// Create an ECMP group with only one member, where the group ID is
// derived from the host MAC.
final MacAddress hostMac = host.mac();
int groupId = macToGroupId(hostMac);
final GroupDescription group = createNextHopGroup(
groupId, Collections.singleton(hostMac), deviceId);
// Map each host IPV6 address to corresponding /128 prefix and obtain a
// flow rule that points to the group ID. In this tutorial we expect
// only one flow rule per host.
final List<FlowRule> flowRules = hostIpv6Addrs.stream()
.map(IpAddress::toIpPrefix)
.filter(IpPrefix::isIp6)
.map(IpPrefix::getIp6Prefix)
.map(prefix -> createRoutingRule(deviceId, prefix, groupId))
.collect(Collectors.toList());
// Helper function to install flows after groups, since here flows
// points to the group and P4Runtime enforces this dependency during
// write operations.
insertInOrder(group, flowRules);
}
/**
* Set up routes on a given device to forward packets across the fabric,
* making a distinction between spines and leaves.
*
* @param deviceId the device ID.
*/
private void setUpFabricRoutes(DeviceId deviceId) {
if (isSpine(deviceId)) {
setUpSpineRoutes(deviceId);
} else {
setUpLeafRoutes(deviceId);
}
}
/**
* Insert routing rules on the given spine switch, matching on leaf
* interface subnets and forwarding packets to the corresponding leaf.
*
* @param spineId the spine device ID
*/
private void setUpSpineRoutes(DeviceId spineId) {
log.info("Adding up spine routes on {}...", spineId);
for (Device device : deviceService.getDevices()) {
if (isSpine(device.id())) {
// We only need routes to leaf switches. Ignore spines.
continue;
}
final DeviceId leafId = device.id();
final MacAddress leafMac = getMyStationMac(leafId);
final Set<Ip6Prefix> subnetsToRoute = getInterfaceIpv6Prefixes(leafId);
// Since we're here, we also add a route for SRv6 (Exercise 7), to
// forward packets with IPv6 dst the SID of a leaf switch.
final Ip6Address leafSid = getDeviceSid(leafId);
subnetsToRoute.add(Ip6Prefix.valueOf(leafSid, 128));
// Create a group with only one member.
int groupId = macToGroupId(leafMac);
GroupDescription group = createNextHopGroup(
groupId, Collections.singleton(leafMac), spineId);
List<FlowRule> flowRules = subnetsToRoute.stream()
.map(subnet -> createRoutingRule(spineId, subnet, groupId))
.collect(Collectors.toList());
insertInOrder(group, flowRules);
}
}
/**
* Insert routing rules on the given leaf switch, matching on interface
* subnets associated to other leaves and forwarding packets the spines
* using ECMP.
*
* @param leafId the leaf device ID
*/
private void setUpLeafRoutes(DeviceId leafId) {
log.info("Setting up leaf routes: {}", leafId);
// Get the set of subnets (interface IPv6 prefixes) associated to other
// leafs but not this one.
Set<Ip6Prefix> subnetsToRouteViaSpines = stream(deviceService.getDevices())
.map(Device::id)
.filter(this::isLeaf)
.filter(deviceId -> !deviceId.equals(leafId))
.map(this::getInterfaceIpv6Prefixes)
.flatMap(Collection::stream)
.collect(Collectors.toSet());
// Get myStationMac address of all spines.
Set<MacAddress> spineMacs = stream(deviceService.getDevices())
.map(Device::id)
.filter(this::isSpine)
.map(this::getMyStationMac)
.collect(Collectors.toSet());
// Create an ECMP group to distribute traffic across all spines.
final int groupId = DEFAULT_ECMP_GROUP_ID;
final GroupDescription ecmpGroup = createNextHopGroup(
groupId, spineMacs, leafId);
// Generate a flow rule for each subnet pointing to the ECMP group.
List<FlowRule> flowRules = subnetsToRouteViaSpines.stream()
.map(subnet -> createRoutingRule(leafId, subnet, groupId))
.collect(Collectors.toList());
insertInOrder(ecmpGroup, flowRules);
// Since we're here, we also add a route for SRv6 (Exercise 7), to
// forward packets with IPv6 dst the SID of a spine switch, in this case
// using a single-member group.
stream(deviceService.getDevices())
.map(Device::id)
.filter(this::isSpine)
.forEach(spineId -> {
MacAddress spineMac = getMyStationMac(spineId);
Ip6Address spineSid = getDeviceSid(spineId);
int spineGroupId = macToGroupId(spineMac);
GroupDescription group = createNextHopGroup(
spineGroupId, Collections.singleton(spineMac), leafId);
FlowRule routingRule = createRoutingRule(
leafId, Ip6Prefix.valueOf(spineSid, 128),
spineGroupId);
insertInOrder(group, Collections.singleton(routingRule));
});
}
//--------------------------------------------------------------------------
// UTILITY METHODS
//--------------------------------------------------------------------------
/**
* Returns true if the given device has isSpine flag set to true in the
* config, false otherwise.
*
* @param deviceId the device ID
* @return true if the device is a spine, false otherwise
*/
private boolean isSpine(DeviceId deviceId) {
return getDeviceConfig(deviceId).map(FabricDeviceConfig::isSpine)
.orElseThrow(() -> new ItemNotFoundException(
"Missing isSpine config for " + deviceId));
}
/**
* Returns true if the given device is not configured as spine.
*
* @param deviceId the device ID
* @return true if the device is a leaf, false otherwise
*/
private boolean isLeaf(DeviceId deviceId) {
return !isSpine(deviceId);
}
/**
* Returns the MAC address configured in the "myStationMac" property of the
* given device config.
*
* @param deviceId the device ID
* @return MyStation MAC address
*/
private MacAddress getMyStationMac(DeviceId deviceId) {
return getDeviceConfig(deviceId)
.map(FabricDeviceConfig::myStationMac)
.orElseThrow(() -> new ItemNotFoundException(
"Missing myStationMac config for " + deviceId));
}
/**
* Returns the FabricDeviceConfig config object for the given device.
*
* @param deviceId the device ID
* @return FabricDeviceConfig device config
*/
private Optional<FabricDeviceConfig> getDeviceConfig(DeviceId deviceId) {
FabricDeviceConfig config = networkConfigService.getConfig(
deviceId, FabricDeviceConfig.class);
return Optional.ofNullable(config);
}
/**
* Returns the set of interface IPv6 subnets (prefixes) configured for the
* given device.
*
* @param deviceId the device ID
* @return set of IPv6 prefixes
*/
private Set<Ip6Prefix> getInterfaceIpv6Prefixes(DeviceId deviceId) {
return interfaceService.getInterfaces().stream()
.filter(iface -> iface.connectPoint().deviceId().equals(deviceId))
.map(Interface::ipAddressesList)
.flatMap(Collection::stream)
.map(InterfaceIpAddress::subnetAddress)
.filter(IpPrefix::isIp6)
.map(IpPrefix::getIp6Prefix)
.collect(Collectors.toSet());
}
/**
* Returns a 32 bit bit group ID from the given MAC address.
*
* @param mac the MAC address
* @return an integer
*/
private int macToGroupId(MacAddress mac) {
return mac.hashCode() & 0x7fffffff;
}
/**
* Inserts the given groups and flow rules in order, groups first, then flow
* rules. In P4Runtime, when operating on an indirect table (i.e. with
* action selectors), groups must be inserted before table entries.
*
* @param group the group
* @param flowRules the flow rules depending on the group
*/
private void insertInOrder(GroupDescription group, Collection<FlowRule> flowRules) {
try {
groupService.addGroup(group);
// Wait for groups to be inserted.
Thread.sleep(GROUP_INSERT_DELAY_MILLIS);
flowRules.forEach(flowRuleService::applyFlowRules);
} catch (InterruptedException e) {
log.error("Interrupted!", e);
Thread.currentThread().interrupt();
}
}
/**
* Gets Srv6 SID for the given device.
*
* @param deviceId the device ID
* @return SID for the device
*/
private Ip6Address getDeviceSid(DeviceId deviceId) {
return getDeviceConfig(deviceId)
.map(FabricDeviceConfig::mySid)
.orElseThrow(() -> new ItemNotFoundException(
"Missing mySid config for " + deviceId));
}
/**
* Sets up IPv6 routing on all devices known by ONOS and for which this ONOS
* node instance is currently master.
*/
private synchronized void setUpAllDevices() {
// Set up host routes
stream(deviceService.getAvailableDevices())
.map(Device::id)
.filter(mastershipService::isLocalMaster)
.forEach(deviceId -> {
log.info("*** IPV6 ROUTING - Starting initial set up for {}...", deviceId);
setUpMyStationTable(deviceId);
setUpFabricRoutes(deviceId);
setUpL2NextHopRules(deviceId);
hostService.getConnectedHosts(deviceId)
.forEach(host -> setUpHostRules(deviceId, host));
});
}
}
Trellis
make reset
make start-v4
onos> app activate fabric
onos> app activate segmentrouting
onos> apps -s -a
onos> cfg set org.onosproject.net.flow.impl.FlowRuleManager fallbackFlowPollFrequency 4
onos> cfg set org.onosproject.net.group.impl.GroupManager fallbackGroupPollFrequency 3
$ make netcfg-sr
h1a ping h1c
h1a ping h2
h2 ping 172.16.2.254
h2 arp
h1a ping h2
h3 ping h2
h3 ping 172.16.3.254
h4 ping 172.16.4.254
pingall
MyTunnel
/*
* Copyright 2017-present Open Networking Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.p4tutorial.mytunnel;
import com.google.common.collect.Lists;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
import org.osgi.service.component.annotations.Reference;
import org.osgi.service.component.annotations.ReferenceCardinality;
import org.onlab.packet.IpAddress;
import org.onosproject.core.ApplicationId;
import org.onosproject.core.CoreService;
import org.onosproject.net.DeviceId;
import org.onosproject.net.Host;
import org.onosproject.net.Link;
import org.onosproject.net.Path;
import org.onosproject.net.PortNumber;
import org.onosproject.net.flow.DefaultFlowRule;
import org.onosproject.net.flow.DefaultTrafficSelector;
import org.onosproject.net.flow.DefaultTrafficTreatment;
import org.onosproject.net.flow.FlowRule;
import org.onosproject.net.flow.FlowRuleService;
import org.onosproject.net.flow.criteria.PiCriterion;
import org.onosproject.net.host.HostEvent;
import org.onosproject.net.host.HostListener;
import org.onosproject.net.host.HostService;
import org.onosproject.net.pi.model.PiActionId;
import org.onosproject.net.pi.model.PiActionParamId;
import org.onosproject.net.pi.model.PiMatchFieldId;
import org.onosproject.net.pi.model.PiTableId;
import org.onosproject.net.pi.runtime.PiAction;
import org.onosproject.net.pi.runtime.PiActionParam;
import org.onosproject.net.topology.Topology;
import org.onosproject.net.topology.TopologyService;
import org.slf4j.Logger;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import static org.slf4j.LoggerFactory.getLogger;
/**
* MyTunnel application which provides forwarding between each pair of hosts via
* MyTunnel protocol as defined in mytunnel.p4.
* <p>
* The app works by listening for host events. Each time a new host is
* discovered, it provisions a tunnel between that host and all the others.
*/
@Component(immediate = true)
public class MyTunnelApp {
private static final String APP_NAME = "org.onosproject.p4tutorial.mytunnel";
// Default priority used for flow rules installed by this app.
//流的下载是有优先级的
private static final int FLOW_RULE_PRIORITY = 100;
private final HostListener hostListener = new InternalHostListener();
private ApplicationId appId;
//这是一个线程安全的数字
private AtomicInteger nextTunnelId = new AtomicInteger();
private static final Logger log = getLogger(MyTunnelApp.class);
//--------------------------------------------------------------------------
// ONOS core services needed by this application.
//--------------------------------------------------------------------------
@Reference(cardinality = ReferenceCardinality.MANDATORY)
private FlowRuleService flowRuleService;
@Reference(cardinality = ReferenceCardinality.MANDATORY)
private CoreService coreService;
@Reference(cardinality = ReferenceCardinality.MANDATORY)
private TopologyService topologyService;
@Reference(cardinality = ReferenceCardinality.MANDATORY)
private HostService hostService;
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
@Activate
public void activate() {
// Register app and event listeners.
log.info("Starting...");
//注册APP
appId = coreService.registerApplication(APP_NAME);
//添加监听器
hostService.addListener(hostListener);
log.info("STARTED", appId.id());
}
@Deactivate
public void deactivate() {
// Remove listeners and clean-up flow rules.
log.info("Stopping...");
//去除监听器
hostService.removeListener(hostListener);
//去除appID的规则
flowRuleService.removeFlowRulesById(appId);
log.info("STOPPED");
}
/**
* Provisions a tunnel between the given source and destination host with
* the given tunnel ID. The tunnel is established using a randomly picked
* shortest path based on the given topology snapshot.
*
* @param tunId tunnel ID
* @param srcHost tunnel source host
* @param dstHost tunnel destination host
* @param topo topology snapshot
*/
private void provisionTunnel(int tunId, Host srcHost, Host dstHost, Topology topo) {
// Get all shortest paths between switches connected to source and
// destination hosts.
DeviceId srcSwitch = srcHost.location().deviceId();
DeviceId dstSwitch = dstHost.location().deviceId();
List<Link> pathLinks;
if (srcSwitch.equals(dstSwitch)) {
// Source and dest hosts are connected to the same switch.
pathLinks = Collections.emptyList();
} else {
// Compute shortest path.
Set<Path> allPaths = topologyService.getPaths(topo, srcSwitch, dstSwitch);
if (allPaths.size() == 0) {
log.warn("No paths between {} and {}", srcHost.id(), dstHost.id());
return;
}
// If many shortest paths are available, pick a random one.
pathLinks = pickRandomPath(allPaths).links();
}
// Tunnel ingress rules.
for (IpAddress dstIpAddr : dstHost.ipAddresses()) {
// In ONOS discovered hosts can have multiple IP addresses.
// Insert tunnel ingress rule for each IP address.
// Next switches will forward based only on tunnel ID.
insertTunnelIngressRule(srcSwitch, dstIpAddr, tunId);
}
// Insert tunnel transit rules on all switches in the path, excluded the
// last one.
for (Link link : pathLinks) {
DeviceId sw = link.src().deviceId();
PortNumber port = link.src().port();
insertTunnelForwardRule(sw, port, tunId, false);
}
// Tunnel egress rule.
PortNumber egressSwitchPort = dstHost.location().port();
insertTunnelForwardRule(dstSwitch, egressSwitchPort, tunId, true);
log.info("** Completed provisioning of tunnel {} (srcHost={} dstHost={})",
tunId, srcHost.id(), dstHost.id());
}
/**
* Generates and insert a flow rule to perform the tunnel INGRESS function
* for the given switch, destination IP address and tunnel ID.
*
* @param switchId switch ID
* @param dstIpAddr IP address to forward inside the tunnel
* @param tunId tunnel ID
*/
private void insertTunnelIngressRule(DeviceId switchId,
IpAddress dstIpAddr,
int tunId) {
PiTableId tunnelIngressTableId = PiTableId.of("c_ingress.t_tunnel_ingress");
// Longest prefix match on IPv4 dest address.
PiMatchFieldId ipDestMatchFieldId = PiMatchFieldId.of("hdr.ipv4.dst_addr");
PiCriterion match = PiCriterion.builder()
.matchLpm(ipDestMatchFieldId, dstIpAddr.toOctets(), 32)
.build();
PiActionParam tunIdParam = new PiActionParam(PiActionParamId.of("tun_id"), tunId);
PiActionId ingressActionId = PiActionId.of("c_ingress.my_tunnel_ingress");
PiAction action = PiAction.builder()
.withId(ingressActionId)
.withParameter(tunIdParam)
.build();
log.info("Inserting INGRESS rule on switch {}: table={}, match={}, action={}",
switchId, tunnelIngressTableId, match, action);
insertPiFlowRule(switchId, tunnelIngressTableId, match, action);
}
/**
* Generates and insert a flow rule to perform the tunnel FORWARD/EGRESS
* function for the given switch, output port address and tunnel ID.
*
* @param switchId switch ID
* @param outPort output port where to forward tunneled packets
* @param tunId tunnel ID
* @param isEgress if true, perform tunnel egress action, otherwise forward
* packet as is to port
*/
//在这里添加流表规则
private void insertTunnelForwardRule(DeviceId switchId,
PortNumber outPort,
int tunId,
boolean isEgress) {
PiTableId tunnelForwardTableId = PiTableId.of("c_ingress.t_tunnel_fwd");
// Exact match on tun_id
PiMatchFieldId tunIdMatchFieldId = PiMatchFieldId.of("hdr.my_tunnel.tun_id");
PiCriterion match = PiCriterion.builder()
.matchExact(tunIdMatchFieldId, tunId)
.build();
// Action depend on isEgress parameter.
// if true, perform tunnel egress action on the given outPort, otherwise
// simply forward packet as is (set_out_port action).
PiActionParamId portParamId = PiActionParamId.of("port");
PiActionParam portParam = new PiActionParam(portParamId, (short) outPort.toLong());
final PiAction action;
if (isEgress) {
// Tunnel egress action.
// Remove MyTunnel header and forward to outPort.
PiActionId egressActionId = PiActionId.of("c_ingress.my_tunnel_egress");
action = PiAction.builder()
.withId(egressActionId)
.withParameter(portParam)
.build();
} else {
// Tunnel transit action.
// Forward the packet as is to outPort.
/*
* TODO EXERCISE: create action object for the transit case.
* Look at the t_tunnel_fwd table in the P4 program. Which of the 3
* actions can be used to simply set the output port? Get the full
* action name from the P4Info file, and use that when creating the
* PiActionId object. When creating the PiAction object, remember to
* add all action parameters as defined in the P4 program.
*
* Hint: the code will be similar to the case when isEgress is true.
*/
PiActionId fwdActionId =PiActionId.of("c_ingress.t_tunnel_fwd");
action=PiAction.builder().withId(fwdActionId).withParameter(portParam).build();
}
log.info("Inserting {} rule on switch {}: table={}, match={}, action={}",
isEgress ? "EGRESS" : "TRANSIT",
switchId, tunnelForwardTableId, match, action);
insertPiFlowRule(switchId, tunnelForwardTableId, match, action);
}
/**
* Inserts a flow rule in the system that using a PI criterion and action.
*
* @param switchId switch ID
* @param tableId table ID
* @param piCriterion PI criterion
* @param piAction PI action
*/
private void insertPiFlowRule(DeviceId switchId, PiTableId tableId,
PiCriterion piCriterion, PiAction piAction) {
FlowRule rule = DefaultFlowRule.builder()
.forDevice(switchId)
.forTable(tableId)
.fromApp(appId)
.withPriority(FLOW_RULE_PRIORITY)
.makePermanent()
.withSelector(DefaultTrafficSelector.builder()
.matchPi(piCriterion).build())
.withTreatment(DefaultTrafficTreatment.builder()
.piTableAction(piAction).build())
.build();
flowRuleService.applyFlowRules(rule);
}
private int getNewTunnelId() {
return nextTunnelId.incrementAndGet();
}
private Path pickRandomPath(Set<Path> paths) {
int item = new Random().nextInt(paths.size());
List<Path> pathList = Lists.newArrayList(paths);
return pathList.get(item);
}
/**
* A listener of host events that provisions two tunnels for each pair of
* hosts when a new host is discovered.
*/
private class InternalHostListener implements HostListener {
@Override
public void event(HostEvent event) {
if (event.type() != HostEvent.Type.HOST_ADDED) {
// Ignore other host events.
return;
}
synchronized (this) {
// Synchronizing here is an overkill, but safer for demo purposes.
Host host = event.subject();
Topology topo = topologyService.currentTopology();
for (Host otherHost : hostService.getHosts()) {
if (!host.equals(otherHost)) {
provisionTunnel(getNewTunnelId(), host, otherHost, topo);
provisionTunnel(getNewTunnelId(), otherHost, host, topo);
}
}
}
}
}
}
e transit case.
* Look at the t_tunnel_fwd table in the P4 program. Which of the 3
* actions can be used to simply set the output port? Get the full
* action name from the P4Info file, and use that when creating the
* PiActionId object. When creating the PiAction object, remember to
* add all action parameters as defined in the P4 program.
*
* Hint: the code will be similar to the case when isEgress is true.
*/
PiActionId fwdActionId =PiActionId.of(“c_ingress.t_tunnel_fwd”);
action=PiAction.builder().withId(fwdActionId).withParameter(portParam).build();
}
log.info("Inserting {} rule on switch {}: table={}, match={}, action={}",
isEgress ? "EGRESS" : "TRANSIT",
switchId, tunnelForwardTableId, match, action);
insertPiFlowRule(switchId, tunnelForwardTableId, match, action);
}
/**
* Inserts a flow rule in the system that using a PI criterion and action.
*
* @param switchId switch ID
* @param tableId table ID
* @param piCriterion PI criterion
* @param piAction PI action
*/
private void insertPiFlowRule(DeviceId switchId, PiTableId tableId,
PiCriterion piCriterion, PiAction piAction) {
FlowRule rule = DefaultFlowRule.builder()
.forDevice(switchId)
.forTable(tableId)
.fromApp(appId)
.withPriority(FLOW_RULE_PRIORITY)
.makePermanent()
.withSelector(DefaultTrafficSelector.builder()
.matchPi(piCriterion).build())
.withTreatment(DefaultTrafficTreatment.builder()
.piTableAction(piAction).build())
.build();
flowRuleService.applyFlowRules(rule);
}
private int getNewTunnelId() {
return nextTunnelId.incrementAndGet();
}
private Path pickRandomPath(Set<Path> paths) {
int item = new Random().nextInt(paths.size());
List<Path> pathList = Lists.newArrayList(paths);
return pathList.get(item);
}
/**
* A listener of host events that provisions two tunnels for each pair of
* hosts when a new host is discovered.
*/
private class InternalHostListener implements HostListener {
@Override
public void event(HostEvent event) {
if (event.type() != HostEvent.Type.HOST_ADDED) {
// Ignore other host events.
return;
}
synchronized (this) {
// Synchronizing here is an overkill, but safer for demo purposes.
Host host = event.subject();
Topology topo = topologyService.currentTopology();
for (Host otherHost : hostService.getHosts()) {
if (!host.equals(otherHost)) {
provisionTunnel(getNewTunnelId(), host, otherHost, topo);
provisionTunnel(getNewTunnelId(), otherHost, host, topo);
}
}
}
}
}
TODO：
另一个学习ONOS+P4的网站：onos/apps/p4-tutorial at master · opennetworkinglab/onos (github.com)
官方的视频：P4-programmable smartNIC controlled by ONOS_哔哩哔哩_bilibili
一个大佬的INTController的：INTCollector部署与验证 - Mabinogi (lzhtan.github.io)
里面的工具有空去用一下：基于ONOS 2.2的带内网络遥测_哔哩哔哩_bilibili
扫一扫
1244
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
