实验6：开源控制器实践——RYU

一、实验目的

能够独立部署RYU控制器；
能够理解RYU控制器实现软件定义的集线器原理；
能够理解RYU控制器实现软件定义的交换机原理。

二、实验环境

Ubuntu 20.04 Desktop amd64

三、实验要求

（一）基本要求

(1) 搭建下图所示SDN拓扑，协议使用Open Flow 1.0，并连接Ryu控制器，通过Ryu的图形界面查看网络拓扑

(2) 阅读Ryu文档的The First Application一节，运行并使用 tcpdump 验证L2Switch

运行L2Switch

h1 ping h2

h1 ping h3

(3)分析L2Switch和POX的Hub模块有何不同

RYU的L2Switch模块和POX的Hub模块都是洪泛转发,但是ryu的L2Switch模块运行时不可查看流表，而pox的Hub模块运行时可查看流表

(4)编程修改L2Switch.py，另存为L2032002126.py，使之和POX的Hub模块的变得一致。

运行L2032002126.py

查看流表

L2032002519.py代码

from ryu.base import app_manager
from ryu.ofproto import ofproto_v1_3
from ryu.controller import ofp_event
from ryu.controller.handler import MAIN_DISPATCHER, CONFIG_DISPATCHER
from ryu.controller.handler import set_ev_cls
 
 
class hub(app_manager.RyuApp):
    OFP_VERSIONS = [ofproto_v1_3.OFP_VERSION]
 
    def __init__(self, *args, **kwargs):
        super(hub, self).__init__(*args, **kwargs)
 
    @set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)
    def switch_feathers_handler(self, ev):
        datapath = ev.msg.datapath
        ofproto = datapath.ofproto
        ofp_parser = datapath.ofproto_parser
 
        # install flow table-miss flow entry
        match = ofp_parser.OFPMatch()
        actions = [ofp_parser.OFPActionOutput(ofproto.OFPP_CONTROLLER, ofproto.OFPCML_NO_BUFFER)]
        # 1\OUTPUT PORT, 2\BUFF IN SWITCH?
        self.add_flow(datapath, 0, match, actions)
 
    def add_flow(self, datapath, priority, match, actions):
        # 1\ datapath for the switch, 2\priority for flow entry, 3\match field, 4\action for packet
        ofproto = datapath.ofproto
        ofp_parser = datapath.ofproto_parser
        # install flow
        inst = [ofp_parser.OFPInstructionActions(ofproto.OFPIT_APPLY_ACTIONS, actions)]
        mod = ofp_parser.OFPFlowMod(datapath=datapath, priority=priority, match=match, instructions=inst)
        datapath.send_msg(mod)
 
    @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
    def packet_in_handler(self, ev):
        msg = ev.msg
        datapath = msg.datapath
        ofproto = datapath.ofproto
        ofp_parser = datapath.ofproto_parser
        in_port = msg.match['in_port']  # get in port of the packet
 
        # add a flow entry for the packet
        match = ofp_parser.OFPMatch()
        actions = [ofp_parser.OFPActionOutput(ofproto.OFPP_FLOOD)]
        self.add_flow(datapath, 1, match, actions)
 
        # to output the current packet. for install rules only output later packets
        out = ofp_parser.OFPPacketOut(datapath=datapath, buffer_id=msg.buffer_id, in_port=in_port, actions=actions)
        # buffer id: locate the buffered packet
        datapath.send_msg(out)

（二）进阶要求

(1)阅读Ryu关于simple_switch.py和simple_switch_1x.py的实现，以simple_switch_13.py为例，完成其代码的注释工作

#
# 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_manager
from ryu.controller import ofp_event
from ryu.controller.handler import CONFIG_DISPATCHER, MAIN_DISPATCHER
from ryu.controller.handler import set_ev_cls
from ryu.ofproto import ofproto_v1_3
from ryu.lib.packet import packet
from ryu.lib.packet import ethernet
from ryu.lib.packet import ether_types


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

  def __init__(self, *args, **kwargs):
      super(SimpleSwitch13, self).__init__(*args, **kwargs)
      self.mac_to_port = {}  # 定义保存mac地址到端口的一个映射

  # 处理SwitchFeatures事件
  @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()  # match指流表项匹配，OFPMatch()指不匹配任何信息
      actions = [parser.OFPActionOutput(ofproto.OFPP_CONTROLLER,
                                        ofproto.OFPCML_NO_BUFFER)]  # actions：动作
      self.add_flow(datapath, 0, match, actions)  # add_flow()增加流表项

  
  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)]
      
      if buffer_id:       # 判断是否存在buffer_id，并生成mod对象
          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)        # send_msg(mod)即为下发流表

  # 处理PacketIn事件
  @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    # ev.msg 是代表packet_in data structure对象
      datapath = msg.datapath
      # dp. ofproto 和 dp.ofproto_parser 是代表 Ryu 和交换机谈判的 OpenFlow 协议的对象
      # dp.ofproto and dp.ofproto_parser are objects that represent the OpenFlow protocol that Ryu and the switch negotiated
      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:
          # 忽略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)

      # 学习包的源地址，和交换机上的入端口绑定
      # 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]:  # 如果目的地址存在于mac_to_port中
          out_port = self.mac_to_port[dpid][dst]
      # 否则，洪泛
      else:
          out_port = ofproto.OFPP_FLOOD  # OFPP_FLOOD标志表示应在所有端口发送数据包，即洪泛

      actions = [parser.OFPActionOutput(out_port)]

      # 下发流表避免下次触发 packet in 事件
      # 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
          if msg.buffer_id != ofproto.OFP_NO_BUFFER:
              self.add_flow(datapath, 1, match, actions, msg.buffer_id)
              return
          else:
              self.add_flow(datapath, 1, match, actions)
      data = None
      if msg.buffer_id == ofproto.OFP_NO_BUFFER:
          data = msg.data

      # 发送Packet_out数据包,带上交换机发来的数据包的信息
      out = parser.OFPPacketOut(datapath=datapath, buffer_id=msg.buffer_id,
                                in_port=in_port, actions=actions, data=data)
      # 发送流表
      datapath.send_msg(out)

(2)回答下列问题

代码当中的mac_to_port的作用是什么？

保存mac地址到交换机端口的映射

simple_switch和simple_switch_13在dpid的输出上有何不同？

在simple_switch_13.py中使用了zfill() 方法返回指定长度为16的字符串，原字符串右对齐，前面填充0；而simple_switch.py直接输出dpid

相比simple_switch，simple_switch_13增加的switch_feature_handler实现了什么功能？

增加了实现交换机以特性应答消息响应特性请求功能

simple_switch_13是如何实现流规则下发的？

在触发PacketIn事件后，首先获取协议信息、获取源端口、包学习，交换机信息，以太网信息等。如果以太网类型是LLDP类型的话，则忽略不处理。否则，则获取目的端口和源端口和交换机id的信息，进行交换机自学习：先学习源地址对应的交换机的入端口，再查看是否已经学习目的mac地址，如果没有学习过就洪泛转发。如果学习过，则查看是否有buffer_id，如果有，那么在添加流时加上buffer_id，向交换机发送数据包和流表

switch_features_handler和_packet_in_handler两个事件在发送流规则的优先级上有何不同？

switch_features_handler下发流表的优先级比_packet_in_handler的高

(3)硬超时功能

四、个人总结

遇到的问题及解决方法

(1)在运行L2switch.py后却一直ping不通，后经过检查，发现是前一步中ryu没有关闭导致错误，关闭之后，问题解决；(2)在运行L2032002519.py时，出现unsupported version 0x1，运行了几遍之后依然不行，就先去看已经完成的同学是否有同样的问题，后经过查找发现还是有一部分同学出现过同样问题，学习了问题出现的根本原因便进行改正，在将版本设置为“protocols=OpenFlow13后”，问题解决

心得体会

本次实验难度适中，总体来说跟着pdf文档就能较为轻松的完成，但是主要的获取的知识是在实验中的一些结论与靠阅读RYU相关模块的源代码获得的。比如ryu的L2Switch模块与pox的Hub模块的不同在于ryu的L2Switch模块运行时不可查看流表，而pox的Hub模块运行时可查看流表。主要是进阶部分会比较艰难一点，代码比较多而且实现的功能需要认真理解，但是坚持读下来，就会对ryu的控制机制有深入的理解与认识

posted @ 2022-10-19 11:23 Edith12 阅读(30) 评论(0) 编辑收藏举报

刷新页面返回顶部

Edith

实验6：开源控制器实践——RYU

实验6：开源控制器实践——RYU

一、实验目的

二、实验环境

三、实验要求

（一）基本要求

（二）进阶要求

四、个人总结

遇到的问题及解决方法

心得体会

公告