1.基础要求
a)回答L2Switch和POX的Hub模块有何不同
通过实验结果可知，相比于POX的Hub模块，L2Switch的相同之处在于二者实现的都是洪泛发送ICMP报文，所以在h1去pingh2时，h2和h3可以看到都有抓到数据包。
不同之处在于：Ryu中L2Switch下发的流表是无法查看的，而POX中Hub模块可以查看。

b)提交修改过的L2xxxxxxxxx.py代码
from ryu.base import app_managerfrom ryu.controller import ofp_eventfrom ryu.controller.handler import MAIN_DISPATCHER, CONFIG_DISPATCHERfrom ryu.controller.handler import set_ev_clsfrom ryu.ofproto import ofproto_v1_3 #openflow版本：1.3(1.3才支持config协议）

定义一个类L2Switch，继承app_manager，位于ryu下的base内，版本选择openflow1.3，然后初始化操作。class L2Switch(app_manager.RyuApp):

OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION] #定义版本

类的初始化函数

def __init__(self, *args, **kwargs): #最后一个是可变参数
    super(L2Switch, self).__init__(*args, **kwargs)

在Ryu控制器上，要写一个函数去处理openvswitch的连接，同时需要开启一个监听，用来监听交换机的事件。 @set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)

def switch_feathers_handler(self, ev):#解析数据#datapath像数据平面的通道，等同于网桥
    dp = ev.msg.datapath
    ofp = dp.ofproto #版本
    ofp_parser = dp.ofproto_parser #基于此版本的一些库类#接收到交换机的连接后，要下发一条tableentrys，一个默认的流表，来指挥所有匹配不到交换机的数据，将其上传到控制器#install the table miss flow entry,即在ryu控制器里安装流表项 #匹配域
    match = ofp_parser.OFPMatch()#动作域：OFPActionOutPut将数据包发送出去#第一个参数：发送端口：控制器（把那些没有匹配的东西给控制器）#第二个参数：数据包在交换机上缓存buffer_id,由于将数据包全部传送到控制器，所以不在交换机上缓存
    actions = [ofp_parser.OFPActionOutput(ofp.OFPP_CONTROLLER, ofp.OFPCML_NO_BUFFER)]
    self.add_flow(dp, 0, match, actions)

为了提高代码重用，对于添加流表，单独写一个函数。

def add_flow(self, datapath, priority, match, actions):#add a flow entry and install it into datapath# 1\ datapath for the switch, 2\priority for flow entry, 3\match field, 4\action for packet
    ofp = dp.ofproto
    ofp_parser = dp.ofproto_parser#1.3版本交换机中需要有指令# install flow# construct a flow_mod msg and sent it
    inst = [ofp_parser.OFPInstructionActions(ofp.OFPIT_APPLY_ACTIONS, actions)]
    mod = ofp_parser.OFPFlowMod(datapath=dp, priority=priority, match=match, instructions=inst)
    dp.send_msg(mod)#需要定义packet in函数，用来处理交换机和控制器之间的流表交互，在执行之前要先对packetin事件进行监听。    @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)#MAIN_DISPATCHER：主状态下监听事件
def packet_in_handler(self, ev):#数据解析
    msg = ev.msg
    dp= msg.datapath
    ofp= dp.ofproto
    ofp_parser = dp.ofproto_parser
    in_port = msg.match['msg.in_port']#match匹配域中提取in_port#发送出去（通过加一个流表）#construct a flow entry
    match = ofp_parser.OFPMatch() #匹配项为空，因为所有取到的内容都要泛洪出去
    actions = [ofp_parser.OFPActionOutput(ofproto.OFPP_FLOOD)]#泛洪动作#调用添加流表的函数，把流表发送出去# install flow mode to avoid match in next time
    self.add_flow(datapath, 1, match, actions)

处理当下的pack_in，将其发出#buffer_id是一个很重要的参数，因为数据包进入交换机，要有地方暂存，到了取的时候就需要有对应的id来指定# to output the current packet. for install rules only output later packets

    out = ofp_parser.OFPPacketOut(datapath=dp, buffer_id=msg.buffer_id, in_port=msg.in_port, actions=actions, data = data)# buffer id: locate the buffered packet
    dp.send_msg(out)

c)能够体现和验证修改的相关截图

2.进阶要求
a)相关问题回答
代码当中的mac_to_port的作用是什么？
mac_to_port是mac地址到交换机端口的一个映射，可用于交换机的自学习。
simple_switch和simple_switch_13在dpid的输出上有何不同？
simple_switch是直接输出dpid，而simple_switch_13是在dpid前端填充0直至满16位。
#simple_switch.py
dpid = datapath.id
#simple_switch_13.py
dpid = format(datapath.id, "d").zfill(16)
相比simple_switch，simple_switch_13增加的switch_feature_handler实现了什么功能？
实现了交换机以特性应答消息去响应特性请求这一功能。
simple_switch_13是如何实现流规则下发的？
在接收到packetin事件后，首先获取包学习，交换机信息，以太网信息，协议信息等等。如果以太网类型是LLDP类型，则不予处理。否则，获取源端口的目的端口和交换机的id，先学习源地址对应的交换机的入端口，再查看是否已经学习目的mac地址。如果没有则进行洪泛转发，否则为学习过该mac地址，那就查看是否有buffer_id，有则在添加流表信息动作时加上buffer_id，向交换机发送流表。
switch_features_handler和_packet_in_handler两个事件在发送流规则的优先级上有何不同？
switch_features_handler下发流表的优先级比_packet_in_handler高。
b)代码的注释

Copyright (C) 2011 Nippon Telegraph and Telephone Corporation.## 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.

进入各类包from ryu.base import app_managerfrom ryu.controller import ofp_eventfrom ryu.controller.handler import CONFIG_DISPATCHER, MAIN_DISPATCHERfrom ryu.controller.handler import set_ev_clsfrom ryu.ofproto import ofproto_v1_3from ryu.lib.packet import packetfrom ryu.lib.packet import ethernetfrom ryu.lib.packet import ether_types

class SimpleSwitch13(app_manager.RyuApp):
OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]#定义openflow的版本为1.3

def __init__(self, *args, **kwargs):
    super(SimpleSwitch13, self).__init__(*args, **kwargs)# 定义保存mac地址到端口的映射，self.mac_to_port是mac地址映射到转发端口的字典。
    self.mac_to_port = {}

处理EventOFPSwitchFeatures事件 @set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)

def switch_features_handler(self, ev): #ev.msg 是用来存储对应事件的 OpenFlow 消息类别实体
    datapath = ev.msg.datapath # ofproto表示使用的OpenFlow版本所对应的ryu.ofproto.ofproto_v1_3
    ofproto = datapath.ofproto # 使用对应版本的ryu.ofproto.ofproto_v1_3_parser来解析协议
    parser = datapath.ofproto_parser

    # install table-miss flow entry
    #
    # We specify NO BUFFER to max_len of the output action due to
    # OVS bug. At this moment, if we specify a lesser number, e.g.,
    # 128, OVS will send Packet-In with invalid buffer_id and
    # truncated packet data. In that case, we cannot output packets
    # correctly.  The bug has been fixed in OVS v2.1.0.
    match = parser.OFPMatch()
    actions = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER,
                                      ofproto.OFPCML_NO_BUFFER)]
    self.add_flow(datapath, 0, match, actions) # priority = 0表示优先级最低，即若所有流表都匹配不到时，才会把数据包发送到controller# 执行 add_flow() 方法以发送 Flow Mod 消息# 添加流表函数
def add_flow(self, datapath, priority, match, actions, buffer_id=None):
    ofproto = datapath.ofproto
    parser = datapath.ofproto_parser# 获取交换机信息
    inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS,
                                         actions)]# 对action进行包装# 判断是否有buffer_id，并生成mod对象
    if buffer_id:
        mod = parser.OFPFlowMod(datapath=datapath, buffer_id=buffer_id,
                                priority=priority, match=match,
                                instructions=inst)
    else:
        mod = parser.OFPFlowMod(datapath=datapath, priority=priority,
                                match=match, instructions=inst)
    datapath.send_msg(mod) # 发送mod# 处理 packet in 事件    @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
def _packet_in_handler(self, ev):
    # If you hit this you might want to increase
    # the "miss_send_length" of your switch
    if ev.msg.msg_len < ev.msg.total_len:
        self.logger.debug("packet truncated: only %s of %s bytes",
                          ev.msg.msg_len, ev.msg.total_len)# 获取包信息，交换机信息，协议等等
    msg = ev.msg
    datapath = msg.datapath
    ofproto = datapath.ofproto
    parser = datapath.ofproto_parser
    in_port = msg.match['in_port']

    pkt = packet.Packet(msg.data)
    eth = pkt.get_protocols(ethernet.ethernet)[0]

    if eth.ethertype == ether_types.ETH_TYPE_LLDP:
        # ignore lldp packet # 忽略LLDP类型的数据包
        return

获取源端口，目的端口

    dst = eth.dst
    src = eth.src

    dpid = format(datapath.id, "d").zfill(16)
    self.mac_to_port.setdefault(dpid, {})

    self.logger.info("packet in %s %s %s %s", dpid, src, dst, in_port)# 学习包的源地址和交换机上的入端口绑定#dpid是交换机的id，src是数据包的源mac地址，in_port是交换机接受到包的端口
    # learn a mac address to avoid FLOOD next time.
    self.mac_to_port[dpid][src] = in_port# 查看是否已经学习过该目的mac地址#如果已经学习到，则向交换机下发流表,并让交换机向相应端口转发包
    if dst in self.mac_to_port[dpid]:
        out_port = self.mac_to_port[dpid][dst]
    # 如果没有，则无法下发流表，进行洪泛转发
    else:
        out_port = ofproto.OFPP_FLOOD

    actions = [parser.OFPActionOutput(out_port)]# 下发流表处理后续包，不再触发PACKETIN事件
    # install a flow to avoid packet_in next time
    if out_port != ofproto.OFPP_FLOOD:
        match = parser.OFPMatch(in_port=in_port, eth_dst=dst, eth_src=src)
        # verify if we have a valid buffer_id, if yes avoid to send both
        # flow_mod & packet_out#buffer_id不为None，控制器只需下发流表的命令，交换机增加了流表项后，位于缓冲区的数据包，会自动转发出去。
        if msg.buffer_id != ofproto.OFP_NO_BUFFER:
            self.add_flow(datapath, 1, match, actions, msg.buffer_id)
            return#buffer_id为None，则控制器不仅要更改交换机的流表项，还要把数据包的信息传给交换机，让交换机把数据包转发出去。
        else:
            self.add_flow(datapath, 1, match, actions)
    data = None
    if msg.buffer_id == ofproto.OFP_NO_BUFFER:
        data = msg.data

    out = parser.OFPPacketOut(datapath=datapath, buffer_id=msg.buffer_id,
                              in_port=in_port, actions=actions, data=data)
    datapath.send_msg(out)# 发送流表

c）编程实现和ODL实验的一样的硬超时功能
代码

Copyright (C) 2011 Nippon Telegraph and Telephone Corporation.## 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.

from ryu.base import app_managerfrom ryu.controller import ofp_eventfrom ryu.controller.handler import CONFIG_DISPATCHER, MAIN_DISPATCHERfrom ryu.controller.handler import set_ev_clsfrom ryu.ofproto import ofproto_v1_3from ryu.lib.packet import packetfrom ryu.lib.packet import ethernetfrom ryu.lib.packet import ether_types

class SimpleSwitch13(app_manager.RyuApp):
OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]

def __init__(self, *args, **kwargs):
    super(SimpleSwitch13, self).__init__(*args, **kwargs)
    self.mac_to_port = {}
@set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)
def switch_features_handler(self, ev):
    datapath = ev.msg.datapath
    ofproto = datapath.ofproto
    parser = datapath.ofproto_parser

    # install table-miss flow entry
    #
    # We specify NO BUFFER to max_len of the output action due to
    # OVS bug. At this moment, if we specify a lesser number, e.g.,
    # 128, OVS will send Packet-In with invalid buffer_id and
    # truncated packet data. In that case, we cannot output packets
    # correctly.  The bug has been fixed in OVS v2.1.0.
    match = parser.OFPMatch()
    actions = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER,
                                      ofproto.OFPCML_NO_BUFFER)]
    self.add_flow(datapath, 0, match, actions)

添加流表函数（执行add_flow()方法以发送flow mod消息）这里加了一个hardtime参数

def add_flow(self, datapath, priority, match, actions, buffer_id=None, hard_timeout=0):
    ofproto = datapath.ofproto
    parser = datapath.ofproto_parser

    inst = [parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS,
                                         actions)]
    if buffer_id:
        mod = parser.OFPFlowMod(datapath=datapath, buffer_id=buffer_id,
                                priority=priority, match=match,
                                instructions=inst, hard_timeout=hard_timeout)
    else:
        mod = parser.OFPFlowMod(datapath=datapath, priority=priority,
                                match=match, instructions=inst, hard_timeout=hard_timeout)
    datapath.send_msg(mod)
@set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
def _packet_in_handler(self, ev):
    # If you hit this you might want to increase
    # the "miss_send_length" of your switch
    if ev.msg.msg_len < ev.msg.total_len:
        self.logger.debug("packet truncated: only %s of %s bytes",
                          ev.msg.msg_len, ev.msg.total_len)
    msg = ev.msg
    datapath = msg.datapath
    ofproto = datapath.ofproto
    parser = datapath.ofproto_parser
    in_port = msg.match['in_port']

    pkt = packet.Packet(msg.data)
    eth = pkt.get_protocols(ethernet.ethernet)[0]

    if eth.ethertype == ether_types.ETH_TYPE_LLDP:
        # ignore lldp packet
        return
    dst = eth.dst
    src = eth.src

    dpid = format(datapath.id, "d").zfill(16)
    self.mac_to_port.setdefault(dpid, {})

    self.logger.info("packet in %s %s %s %s", dpid, src, dst, in_port)

    # learn a mac address to avoid FLOOD next time.
    self.mac_to_port[dpid][src] = in_port

    if dst in self.mac_to_port[dpid]:
        out_port = self.mac_to_port[dpid][dst]
    else:
        out_port = ofproto.OFPP_FLOOD

    actions = [parser.OFPActionOutput(out_port)]\

    actions_timeout=[]

    # install a flow to avoid packet_in next time
    if out_port != ofproto.OFPP_FLOOD:
        match = parser.OFPMatch(in_port=in_port, eth_dst=dst, eth_src=src)
        # verify if we have a valid buffer_id, if yes avoid to send both
        # flow_mod & packet_out
        hard_timeout=10 #设置硬超时时间为10s#buffer_id不为None，控制器只需下发流表的命令同时实现硬超时功能，交换机增加了流表项后，位于缓冲区的数据包，会自动转发出去。#此条中带有硬超时功能的优先级为2
        if msg.buffer_id != ofproto.OFP_NO_BUFFER:
            self.add_flow(datapath, 2, match,actions_timeout, msg.buffer_id,hard_timeout=10)
            self.add_flow(datapath, 1, match, actions, msg.buffer_id)
            return#buffer_id为None，则控制器不仅要更改交换机的流表项，还要把数据包的信息传给交换机，让交换机把数据包转发出去。#此条中带有硬超时功能的优先级为2
        else:
            self.add_flow(datapath, 2, match, actions_timeout, hard_timeout=10)
            self.add_flow(datapath, 1, match, actions)
    data = None
    if msg.buffer_id == ofproto.OFP_NO_BUFFER:
        data = msg.data

    out = parser.OFPPacketOut(datapath=datapath, buffer_id=msg.buffer_id,
                              in_port=in_port, actions=actions, data=data)
    datapath.send_msg(out)

运行结果截图

交换机流表项截图

3.个人总结
a）实验感想
在本次实验中，通过阅读RYU文档以及查看相关模块的源代码，进一步了解了RYU控制器的工作原理，比较了RYU的L2Switch模块与POX的Hub模块的相同之处和不同之处。