cd mininet

gedit mymininet.py

 #!/usr/bin/python

 #coding:utf-8

 # 调用关于mininet和time的一些模块

 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

 #定义mynet函数

 def myNet(cname='controller', cargs='-v ptcp:'):

 #通过使用OVS抓取来创建网络

 #诊断信息然后开始创建节点,其中有控制器C0和交换机s0,s1,还有主机h0,h1

 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)

 #链路0,1,2分别表示h0和s0，s0和s1，h1和s1的链路并调用以上两行的参数

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

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

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

 #MAC地址设置：按照拓扑图来设置的，这一块有些不理解，个人理解为，链路0，2只需要设置一个能连上

 #s0/s1的端口就行，而1需要左边的s0端口和右边的s1端口

 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")

 #诊断后设置主机ip

 info( "*** Configuring hosts\n" )

 h0.setIP( '192.168.123.1/24' )

 h1.setIP( '192.168.123.2/24' )

 #通过使用OVS开始网络连接，然后单引号里的意思是搭建和删除桥梁

 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 )

 # 控制器和交换机同属根命名空间所以我们可以通过环回接口连接，对了，10.0.0.13是别的up主的主机

 # ip，需要用自己的，因为控制器是你自己的

 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' )

 #运行测试20次h0和h1的传输情况

 #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' )

 #主函数，看不懂，意思应当是如果是个主函数就设定info的等级然后开始获取网络demo然后运行

 #mynet（）函数

 if __name__ == '__main__':

 setLogLevel( 'info' )

 info( '*** Scratch network demo (kernel datapath)\n' )

 Mininet.init()

 myNet()

cd pox

gedit flow_stats.py

 #!/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()

 #初始化网络的参数0

 src_dpid = 0

 dst_dpid = 0

 input_pkts = 0

 output_pkts = 0

 def getTheTime():

 #设定当地时间的函数

 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

 # 用于将请求发送到连接到控制器的所有交换机的定时器功能的处理程序

 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))

 # 显示在事件的JSON格式结构中接收到的流统计信息的处理程序由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, "%"

 # 处理程序以显示JSON格式接收的端口统计信息

 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)

 # 启动模块的主函数

 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)

 # 定时器每5秒执行一次

 Timer(1, _timer_func, recurring=True)