首页 > Web开发 > 详细

实验 3:Mininet 实验——测量路径的损耗率

时间:2020-09-17 00:59:48      阅读:55      评论:0      收藏:0      [点我收藏+]
实验 3:Mininet 实验——测量路径的损耗率
一、实验目的

  在实验 2 的基础上进一步熟悉 Mininet 自定义拓扑脚本,以及与损耗率相关的设定;初步了解 Mininet 安装时自带的 POX 控制器脚本编写,测试路径损耗率。

二、实验任务

  h0 向 h1 发送数据包,由于在 Mininet 脚本中设置了连接损耗率,在传输过程中会丢失一些包,本次实验的目的是展示如何通过控制器计算路径损耗速率(h0-s0-s1-h1)。这里假设控制器预先知道网络拓扑。控制器将向 s0 和 s1 发送flow_stats_request,当控制器接收到来自 s0 的 response 时,将特定流的数据包数保存input_pkts 中,当控制器接收到来自 s1 的 response 时,将接收到特定流的数据包数保存在 output_pkts 中,差值就是丢失的数据包数量。基于上述拓扑,编写 Mininet 脚本,设置特定的交换机间的路径损耗速率,然后编写 POX 控制器脚本,实现对路径的损耗率的测量。

三、实验要求

  1. 根据实验步骤重复上述实验。

  2. 在博客园发表一篇博客,记录主要步骤。

四、实验步骤
  1. 实验环境
    安装了 Ubuntu 18.04.5 Desktop amd64 的虚拟机
  2. 实验过程

    SDNLAB 实验参考资料:https://www.sdnlab.com/15100.html

   (1)新建并编辑 pox 脚本 flowstat.py:

    此步骤需取得root权限,故而:

    $ sudo passwd root//在键盘上输入密码屏幕不会显示,输完点击enter

    $ su//输入刚刚设置的密码

    获取了root权限则开始新建pox脚本flowstat.py

    # cd sdn

    # cd pox

    # vim flowstat.py# touch flowstat.py//新建脚本mymininet3.py

    # nano flowstat.py//编辑文本内容

    并在在 pox 安装目录下(Mininet 完整安装包含了 pox)执行以下命令运行 pox 脚本

    $ ./pox.py flowstat

    具体步骤如下图

 技术分享图片

   其中flowstat.py的内容参考本文前部分链接内,记为文本1,详情看六、附件

(  现在一起看下 flowstat.py 的关键代码:

   第 7 行开始,让 h0 ping h1,监测 s0 和 s1 之间的链路。

  ? 如果匹配到以太网类型的包头(0x0800),并且数据包的目的 IP 地址是192.168.123.2(对照后面 Mininet 的脚本发现是 h1),并且连接到控制器的数据平面设备 id 是 s0(h0 ping h1,链路 s0-s1 上数据包是从 s0 流向 s1,s0 为源,s1 为目的地),执行 input_pkts = f.packet_count,把数据包数量存入input_pkts;

  ? 同理,如果连接到控制器的数据平面设备 id 是 s1,执行 output_pkts =f.packet_count,把数据包数量存入 output_pkts。

  ? 最后求 input_pkts 和 output_pkts 的差值。一般情况下差值为正,说明链路上数据包有损耗。

    def _handle_flowstats_received (event):

    #stats = flow_stats_to_list(event.stats)

    #log.debug("FlowStatsReceived from %s: %s", dpidToStr(event.connection.dpid), stats)

    global src_dpid, dst_dpid, input_pkts, output_pkts

    #print "src_dpid=", dpidToStr(src_dpid), "dst_dpid=", dpidToStr(dst_dpid)

    for f in event.stats:

    if f.match.dl_type==0x0800 and f.match.nw_dst==IPAddr("192.168.123.2") and f.match.nw_tos==0x64

    and event.connection.dpid==src_dpid:

    #print "input: ", f.byte_count, f.packet_count

    input_pkts = f.packet_count

    if f.match.dl_type==0x0800 and f.match.nw_dst==IPAddr("192.168.123.2") and f.match.nw_tos==0x64

    and event.connection.dpid==dst_dpid:

    #print "output: ", f.byte_count, f.packet_count

    output_pkts = f.packet_count

    if input_pkts !=0:

    print getTheTime(), "Path Loss Rate =", (input_pkts-output_pkts)*1.0/input_pkts*100, "%"

(此部分为flowstat.py文本内容的一些解释)

   (2)编辑 Mininet 脚本 mymininet3.py

    重新开一个新的终端窗口

    参照拓扑图,新建并编辑 Mininet 脚本 mymininet3.py,命令如下:

    $ cd sdn

    $ cd mininet

    $ vim mymininet3.py$ touch mymininet3.py//新建脚本mymininet3.py

    $ nano mymininet3.py//编辑,内容参考文章开头链接内,记为文本2,详见六、附件

    控制器因为安装在本机,所以需修改参考资料代码中的控制器地址为 127.0.0.1:6633。

      switch.cmd( ‘ovs-vsctl set-controller dp0 tcp:127.0.0.1:6633‘ )

      switch1.cmd( ‘ovs-vsctl set-controller dp1 tcp:127.0.0.1:6633‘ )

    设置 s0 和 s1 之间链路的丢包率为 0 info( "*** Creating links\n" )

      linkopts0=dict(bw=100, delay=‘1ms‘, loss=0)

      linkopts1=dict(bw=100, delay=‘1ms‘, loss=0)

      link0=TCLink( h0, switch, **linkopts0)

      link1 = TCLink( switch, switch1, **linkopts1)

      link2 = TCLink( h1, switch1, **linkopts0)

    再执行命令运行 Mininet 脚本 mymininet3.py

    $ sudo python mymininet3.py

技术分享图片

 

 技术分享图片

    Ping 默认是每 1 秒钟测一次,ping 的结果会显示一个丢包率,这里的丢包率是根据 ping 不通的次数占总次数的百分比计算得到的。上图中由于一共 ping 了 20次,每次都能通,所以丢包率是 0。观察 pox 侧的实时状态更新如下图。可知平均丢包率为 0,结果符合 Mininet 脚本中设置的损耗率,也有可能出现负值,可以认为没有丢包。

技术分享图片

    如果修改代码中 s0 和 s1 之间链路的丢包率为 10。即:

技术分享图片

     则:

技术分享图片

 

 技术分享图片

    重新运行 Mininet 脚本 mymininet3.py,20 秒时间的 ping 过程中有 icmp_seq 为2/4/14/16/19/20 共 6 次 ping 不通,所以丢包率计算为 30%。(此为示例数据,实际有偏差为正常现象)

    POX 端重新测试,会发现出现丢包现象,但是实际测量出的丢包率会有浮动,链路的性能总体受到了限制。结果如下图:

技术分享图片

 

 五、过程错误

  • 未使用root权限编辑flowstat.py文本使得文本内容不能保存。
  • 输完$ sudo python mymininet3.py命令出现如下情况(即....点了三四行还在继续,原因未知)(因后来重开虚拟机后输入$ nano mymininet3.py后显示文本无内容,盲猜是保存未成功?)技术分享图片
  •  之前的拓扑未删净——$ sudo mn -c

  • 名称输错:mymininet3漏了个3

六、附件(文本内容)

文本1:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
#!/usr/bin/python
# Copyright 2012 William Yu
# wyu@ateneo.edu
#
# This file is part of POX.
#
# POX is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# POX is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with POX. If not, see <http://www.gnu.org/licenses/>.
#
 
"""
This is a demonstration file created to show how to obtain flow
and port statistics from OpenFlow 1.0-enabled switches. The flow
statistics handler contains a summary of web-only traffic.
"""
 
# standard includes
from pox.core import core
from pox.lib.util import dpidToStr
import pox.openflow.libopenflow_01 as of
from pox.lib.addresses import IPAddr, EthAddr
 
# include as part of the betta branch
from pox.openflow.of_json import *
from pox.lib.recoco import Timer
import time
 
log = core.getLogger()
 
src_dpid = 0
dst_dpid = 0
input_pkts = 0
output_pkts = 0
 
def getTheTime():  #fuction to create a timestamp
  flock = time.localtime()
  then = "[%s-%s-%s" %(str(flock.tm_year),str(flock.tm_mon),str(flock.tm_mday))
  
  if int(flock.tm_hour)<10:
    hrs = "0%s" % (str(flock.tm_hour))
  else:
    hrs = str(flock.tm_hour)
  if int(flock.tm_min)<10:
    mins = "0%s" % (str(flock.tm_min))
  else:
    mins = str(flock.tm_min)
  if int(flock.tm_sec)<10:
    secs = "0%s" % (str(flock.tm_sec))
  else:
    secs = str(flock.tm_sec)
  then +="]%s.%s.%s" % (hrs,mins,secs)
  return then
 
# handler for timer function that sends the requests to all the
# switches connected to the controller.
def _timer_func ():
  for connection in core.openflow._connections.values():
    connection.send(of.ofp_stats_request(body=of.ofp_flow_stats_request()))
    connection.send(of.ofp_stats_request(body=of.ofp_port_stats_request()))
  log.debug("Sent %i flow/port stats request(s)", len(core.openflow._connections))
 
# handler to display flow statistics received in JSON format
# structure of event.stats is defined by ofp_flow_stats()
def _handle_flowstats_received (event):
   #stats = flow_stats_to_list(event.stats)
   #log.debug("FlowStatsReceived from %s: %s", dpidToStr(event.connection.dpid), stats)
   global src_dpid, dst_dpid, input_pkts, output_pkts
   #print "src_dpid=", dpidToStr(src_dpid), "dst_dpid=", dpidToStr(dst_dpid)
   for f in event.stats:
     if f.match.dl_type==0x0800 and f.match.nw_dst==IPAddr("192.168.123.2") and f.match.nw_tos==0x64 and event.connection.dpid==src_dpid:
       #print "input: ", f.byte_count, f.packet_count
       input_pkts = f.packet_count
     if f.match.dl_type==0x0800 and f.match.nw_dst==IPAddr("192.168.123.2") and f.match.nw_tos==0x64 and event.connection.dpid==dst_dpid:
       #print "output: ", f.byte_count, f.packet_count  
       output_pkts = f.packet_count
       if input_pkts !=0:
         print getTheTime(), "Path Loss Rate =", (input_pkts-output_pkts)*1.0/input_pkts*100, "%"
 
# handler to display port statistics received in JSON format
def _handle_portstats_received (event):
   #print "\n<<<STATS-REPLY: Return PORT stats for Switch", event.connection.dpid,"at ",getTheTime()
   #for f in event.stats:
      #if int(f.port_no)<65534:
        #print "   PortNo:", f.port_no, " Fwd‘s Pkts:", f.tx_packets, " Fwd‘s Bytes:", f.tx_bytes, " Rc‘d Pkts:", f.rx_packets, " Rc‘s Bytes:", f.rx_bytes
        #print "   PortNo:", f.port_no,  " TxDrop:", f.tx_dropped, " RxDrop:", f.rx_dropped, " TxErr:", f.tx_errors, " RxErr:", f.rx_errors, " CRC:", f.rx_crc_err, " Coll:", f.collisions
  stats = flow_stats_to_list(event.stats)
  log.debug("PortStatsReceived from %s: %s", dpidToStr(event.connection.dpid), stats)
 
def _handle_ConnectionUp (event):
  global src_dpid, dst_dpid
  print "ConnectionUp: ", dpidToStr(event.connection.dpid)
  for m in event.connection.features.ports:
    if m.name == "s0-eth0":
      src_dpid = event.connection.dpid
    elif m.name == "s1-eth0":
      dst_dpid = event.connection.dpid
 
  msg = of.ofp_flow_mod()
  msg.priority =1
  msg.idle_timeout = 0
  msg.match.in_port =1
  msg.actions.append(of.ofp_action_output(port = of.OFPP_ALL))
  event.connection.send(msg)
 
  msg = of.ofp_flow_mod()
  msg.priority =1
  msg.idle_timeout = 0
  msg.match.in_port =2
  msg.actions.append(of.ofp_action_output(port = of.OFPP_ALL))
  event.connection.send(msg)
 
  msg = of.ofp_flow_mod()
  msg.priority =10
  msg.idle_timeout = 0
  msg.hard_timeout = 0
  msg.match.dl_type = 0x0800
  msg.match.nw_tos = 0x64
  msg.match.in_port=1
  msg.match.nw_dst = "192.168.123.2"
  msg.actions.append(of.ofp_action_output(port = 2))
  event.connection.send(msg)
 
  msg = of.ofp_flow_mod()
  msg.priority =10
  msg.idle_timeout = 0
  msg.hard_timeout = 0
  msg.match.dl_type = 0x0800
  msg.match.nw_tos = 0x64
  msg.match.nw_dst = "192.168.123.1"
  msg.actions.append(of.ofp_action_output(port = 1))
  event.connection.send(msg)
    
# main functiont to launch the module
def launch ():
  # attach handsers to listners
  core.openflow.addListenerByName("FlowStatsReceived",
    _handle_flowstats_received)
  core.openflow.addListenerByName("PortStatsReceived",
    _handle_portstats_received)
  core.openflow.addListenerByName("ConnectionUp", _handle_ConnectionUp)
 
  # timer set to execute every five seconds
  Timer(1, _timer_func, recurring=True)

文本2:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
#!/usr/bin/python
 
from mininet.net import Mininet
from mininet.node import Node
from mininet.link import TCLink
from mininet.log import  setLogLevel, info
from threading import Timer
from mininet.util import quietRun
from time import sleep
 
def myNet(cname=‘controller‘, cargs=‘-v ptcp:‘):
    "Create network from scratch using Open vSwitch."
    info( "*** Creating nodes\n" )
    controller = Node( ‘c0‘, inNamespace=False )
    switch = Node( ‘s0‘, inNamespace=False )
    switch1 = Node( ‘s1‘, inNamespace=False )
    h0 = Node( ‘h0‘ )
    h1 = Node( ‘h1‘ )
    
    info( "*** Creating links\n" )
    linkopts0=dict(bw=100, delay=‘1ms‘, loss=0)
    linkopts1=dict(bw=100, delay=‘1ms‘, loss=10)
    link0=TCLink( h0, switch, **linkopts0)
    link1 = TCLink( switch, switch1, **linkopts1)    
    link2 = TCLink( h1, switch1, **linkopts0)
    #print link0.intf1, link0.intf2
    link0.intf2.setMAC("0:0:0:0:0:1")
    link1.intf1.setMAC("0:0:0:0:0:2")
    link1.intf2.setMAC("0:1:0:0:0:1")
    link2.intf2.setMAC("0:1:0:0:0:2")
 
    info( "*** Configuring hosts\n" )
    h0.setIP( ‘192.168.123.1/24‘ )
    h1.setIP( ‘192.168.123.2/24‘ )
      
    info( "*** Starting network using Open vSwitch\n" )
    switch.cmd( ‘ovs-vsctl del-br dp0‘ )
    switch.cmd( ‘ovs-vsctl add-br dp0‘ )
    switch1.cmd( ‘ovs-vsctl del-br dp1‘ )
    switch1.cmd( ‘ovs-vsctl add-br dp1‘ )
 
    controller.cmd( cname + ‘ ‘ + cargs + ‘&‘ )    
    for intf in switch.intfs.values():
        print intf
        print switch.cmd( ‘ovs-vsctl add-port dp0 %s‘ % intf )
    for intf in switch1.intfs.values():
        print intf
        print switch1.cmd( ‘ovs-vsctl add-port dp1 %s‘ % intf )
  
    # Note: controller and switch are in root namespace, and we
    # can connect via loopback interface
    switch.cmd( ‘ovs-vsctl set-controller dp0 tcp:10.0.0.13:6633‘ )
    switch1.cmd( ‘ovs-vsctl set-controller dp1 tcp:10.0.0.13:6633‘ )
  
    info( ‘*** Waiting for switch to connect to controller‘ )
    while ‘is_connected‘ not in quietRun( ‘ovs-vsctl show‘ ):
        sleep( 1 )
        info( ‘.‘ )
    info( ‘\n‘ )
 
    #info( "*** Running test\n" )
    h0.cmdPrint( ‘ping -Q 0x64 -c 20 ‘ + h1.IP() )
    
    sleep( 1 )
    info( "*** Stopping network\n" )
    controller.cmd( ‘kill %‘ + cname )
    switch.cmd( ‘ovs-vsctl del-br dp0‘ )
    switch.deleteIntfs()
    switch1.cmd( ‘ovs-vsctl del-br dp1‘ )
    switch1.deleteIntfs()
    info( ‘\n‘ )
 
if __name__ == ‘__main__‘:
    setLogLevel( ‘info‘ )
    info( ‘*** Scratch network demo (kernel datapath)\n‘ )
    Mininet.init()
    myNet()

 注意:红色部分按实验内容应修改改的地方。

 

实验 3:Mininet 实验——测量路径的损耗率

原文:https://www.cnblogs.com/w031802535/p/13682224.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!