Ryu is a component-based software defined networking framework. Ryu provides software components with well defined API that make it easy for developers to create new network management and control applications. Ryu supports various protocols for managing network devices, such as OpenFlow, Netconf, OF-config, etc. About OpenFlow, Ryu supports fully 1.0, 1.2, 1.3, 1.4, 1.5 and Nicira Extensions. All of the code is freely available under the Apache 2.0 license.

實戰錄 | 絕對干貨！SDN controller Ryu答

隨着雲計算、大數據等業務的興起，對網絡的改造需求越來越迫切，底層網絡資源如何能更好的為上層業務及應用服務，做到資源的靈活調度和按需交付至關重要。那么，SDN這樣新型的網絡架構就應運而生。

SDN（Software Defined Networking，軟件定義網絡）是一種新型的基於軟件的網絡架構及技術，其最大的特點在於松耦合的控制平面和數據平面，支持集中化的網絡狀態控制，實現底層網絡設施對上層應用的透明。它具有靈活的軟件編程能力，使得網絡的自動化管理和控制能力獲得了空前的提升，能夠有效的解決當前網絡系統所面臨的資源規模擴展有限、組網靈活性差、難以快速滿足業務需求等問題。

SDN具有三大特性：集中控制、開放接口、網絡虛擬化。在SDN架構中包含應用層、控制層、轉發層。其中控制層尤為重要，SDN控制器由於人的大腦一樣，進行總體管控。

在當今市場，SDN控制器五花八門，各種各樣。不同的控制器有不同的優點和特性。其中Open daylight、ONOS、Floodlight、ryu等控制器比較典型，被業界廣泛應用。

尤其是Ryu因其架構簡單，部署方便，便於擴展得以廣泛應用，尤其適用於中小型網絡架構的流量調度和控制。

Ryu是日本NTT公司主導開發的開源項目，其字面意思是日語中“Flow”的意思。Ryu調度目標是提供一個擁有邏輯上集中控制能力的SDN操作系統，該系統具有設計完備的API接口，使網絡應用者能夠便捷的創建新的管理和控制應用。Ryu用python語言編寫，完全遵守Apache許可證，能夠支持v1.0、v1.2、v1.3等多個版本的openflow協議。

Ryu控制器中包含了大量的庫函數和組件供SDN的應用的開發。其中庫函數是Ryu針對SDN控制器需求抽取的一些共性功能。這些庫函數可以在組件中被直接調用，而組件之間的關系是相互獨立的。Ryu提供的庫函數和組件如下圖：

Netconf、OF-conf、Sflow等庫函數主要實現對Openflow 交換機的控制功能。在幾個重要的組件中，OF-wire主要實現對openflow不同協議版本的支持，Topology主要實現對拓撲圖構建，已經鏈路狀態的跟蹤，OF REST主要提供REST API 共用戶配置openflow 交換機。VRRP組件用於在openflow交換機上添加VRRP能力，有效的改善網絡的可靠性。另外可以和openstack雲計算平台整合，使用戶可以按需調度和使用控制其網絡。

Ryu SDN framework主要提供控制能力，通過北向接口的Rest API為SDN apps提供服務，供SDN apps調度和控制流量和網絡。通過南向接口的Openflow等協議控制openflow交換機，完成流量交互。其中Ryu SDN framework起到了承上啟下的作用，是那北向接口的控制和交換中樞。

該層大致分為三類，第一類是oprator，通過RESTful management進行對SDN frame work進行控制和管理。第二類是OpenStack cloud or chestration，通過REST API for Quantum進行和openstack結合，進行網絡的管理和控制。第三類是User apps，通過User-defined API via REST or RPC進行對SDN framework的控制和管理。

這一層是Ryu框架層，主要包含OF REST,topology, discovery,filewall等組件。主要用於SDN控制器的核心功能實現，包含流表下發，拓撲發現等功能。

這一層主要包含支持openflow協議的交換機，包含軟件交換機和物理交換機，軟件交換機包括ovs等。硬件交換機包括盛科SDN交換機等。

Ryu做為控制器，OVS做為交換機，Ryu控制器控制兩個OVS交換機。

在insmod 內核模塊的時候，可以提示insmod內核模塊失敗，失敗的原因如下：

依賴nf_conntrack,nf_defrag_ipv6,libcrc32c,gre,nf_defrag_ipv4，需要把這些模塊insmod后，才能insmod openvswitch.ko模塊。

由於進入創建的docker下載的官方centos7鏡像不包含ifconfig、netstat等工具，需要進行下載：

命令行：docker commit -m “centos 添加net工具” c2beb728796d centos/net

通過運行app目錄下的simple_switch.py，主要用於二層交換，實現二層交換功能。

如果ryu運行不加載二層交換app，運行后，通過docker host1 不能ping同docker host2。

Ryu的結構簡潔，層次分明。由於時間問題，還沒有進行更多場景的app測試和性能測試，有機會后面會有更詳盡的補充。

通過上面的描述，可見可以通過Ryu搭建自己的SDN 控制器，通過編寫自己的app來滿足自己特定的需求。但是Ryu也有自己的缺點，主要表現在對集群不支持，沒有支持多級流表等方面。

最近一直在進行RYU控制器的研究，其實也就是學習吧，從初學者慢慢做起，希望可以將基於RYU控制器將SDN/OpenFlow相關的開源控制器進行深入的研究，並且和大家分享一些有幫助的信息。

在ryu的安裝一直遇到問題，ryu的安裝分為Python的安裝、RYU所需相關依賴包的安裝、安裝工具pip和Git的安裝、RYU的安裝

我的安裝環境是Linux Ubuntu 12.04的版本上進行安裝的，在Linux安裝的時候已經安裝了Python，我們需要進行Python版本的查看：python -V（此處V要大寫），顯示的版本信息如下：

RYU對Python的版本要求是2.7+，因此如果自己的版本不夠的話，就需要進行升級了，安裝后如果還是2.6版本的話，那么就需要手動修改了vim ~/.bashrc ：

所需的依賴包有python-eventlet、python-routes、python-webob以及python-paramiko，在ubuntu上的安裝就可以用apt-get install命令：

安裝完后，一定要對pip進行更新，因為我在沒有更新pip之前，進行安裝的RYU總是報錯如下：

這個問題困擾好長時間，后來將pip進行更新，然后，重新啟動系統，再進行安裝，后來就成功了

更新的命令：pip install --upgrade pip或者pip install -U pip更新后，就可以進行下面的RYU的安裝

運行命令：pip list會顯示已經安裝的軟件以及相應的版本號。例如：

1 前言

輾轉了POX, NOX, OpenDaylight等多個控制器之后，我終於意識到我只喜歡python語言的控制器。但是我依然記得OpenDaylight的Nullpointer的Exception，還記得YANG文件的深奧，但是OpenDaylight讓我對控制器開發的興趣減少了，這不是我想要的事情。最后，我下決定轉向RYU。我突然發現，生活突然變得很美好。我用着我熟悉的，喜歡的，優美的python，寫着充滿美感的語句，猶如寫詩一般的愜意。

本篇主要介紹如何安裝RYU，和如何在RYU上開發APP。

2 RYU的安裝

安裝RYU，需要安裝一些python的套件：

python-eventlet
python-routes
python-webob
python-paramiko

安裝RYU主要有兩種方式：

pip安裝

pip install ryu

1	pip install ryu

下載源文件安裝

git clone git://github.com/osrg/ryu.git
cd ryu
sudo pip install -r tools/pip-requires
sudo python setup.py install

git clone git://github.com/osrg/ryu.git

cd ryu

sudo pip install -r tools/pip-requires

sudo python setup.py install

若還有更多問題，可參考@linton小伙伴的博客

3 RYU使用

安裝RYU之后，進入ryu目錄，輸入：

ryu-manager yourapp.py

1	ryu-manager yourapp.py

運行對應的APP，如

ryu-manager simple_switch.py

1	ryu-manager simple_switch.py

4 RYU源碼分析

當我安裝好了RYU之后，第一件事就是迫不及待地去看它的源碼，其可讀性之高，超出我的想象。
下面介紹ryu/ryu目錄下的主要目錄內容。

base

base中有一個非常重要的文件：app_manager.py，其作用是RYU應用的管理中心。用於加載RYU應用程序，接受從APP發送過來的信息，同時也完成消息的路由。

其主要的函數有app注冊、注銷、查找、並定義了RYUAPP基類，定義了RYUAPP的基本屬性。包含name, threads, events, event_handlers和observers等成員，以及對應的許多基本函數。如：start(), stop()等。

這個文件中還定義了AppManager基類，用於管理APP。定義了加載APP等函數。不過如果僅僅是開發APP的話，這個類可以不必關心。

controller

controller文件夾中許多非常重要的文件，如events.py, ofp_handler.py, controller.py等。其中controller.py中定義了OpenFlowController基類。用於定義OpenFlow的控制器，用於處理交換機和控制器的連接等事件，同時還可以產生事件和路由事件。其事件系統的定義，可以查看events.py和ofp_events.py。

在ofp_handler.py中定義了基本的handler（應該怎么稱呼呢？句柄？處理函數？），完成了基本的如：握手，錯誤信息處理和keep alive 等功能。更多的如packet_in_handler應該在app中定義。

在dpset.py文件中，定義了交換機端的一些消息，如端口狀態信息等，用於描述和操作交換機。如添加端口，刪除端口等操作。

其他的文件不再贅述。

lib中定義了我們需要使用到的基本的數據結構，如dpid, mac和ip等數據結構。在lib/packet目錄下，還定義了許多網絡協議，如ICMP, DHCP, MPLS和IGMP等協議內容。而每一個數據包的類中都有parser和serialize兩個函數。用於解析和序列化數據包。

lib目錄下，還有ovs, netconf目錄，對應的目錄下有一些定義好的數據類型，不再贅述。

ofproto

在這個目錄下，基本分為兩類文件，一類是協議的數據結構定義，另一類是協議解析，也即數據包處理函數文件。如ofproto_v1_0.py是 1.0版本的OpenFlow協議數據結構的定義，而ofproto_v1_0_parser.py則定義了1.0版本的協議編碼和解碼。具體內容不贅述，實現功能與協議相同。

topology

包含了switches.py等文件，基本定義了一套交換機的數據結構。event.py定義了交換上的事件。dumper.py定義了獲取網絡拓撲的內容。最后api.py向上提供了一套調用topology目錄中定義函數的接口。

contrib

這個文件夾主要存放的是開源社區貢獻者的代碼。我沒看過。

定義了RYU的命令系統，具體不贅述。

services

完成了BGP和vrrp的實現。具體我還沒有使用這個模塊。

tests

tests目錄下存放了單元測試以及整合測試的代碼，有興趣的讀者可以自行研究。

5 開發你自己的RYU應用程序

大概瀏覽了一下RYU的源代碼，相信看過OpenDaylight的同學會發現，太輕松了！哈哈，我想我真的不喜歡maven, osgi, xml, yang以及java，但是不能不承認OpenDaylight還是很牛逼的，在學習的讀者要堅持啊！

開發RYU的APP，真的再簡單不過了。先來最簡單的：

 
              Python 
             
             from ryu.base import app_manager

class L2Switch(app_manager.RyuApp):
    def __init__(self, *args, **kwargs):
        super(L2Switch, self).__init__(*args, **kwargs) 
            
                    1 
                  
                    2 
                  
                    3 
                  
                    4 
                  
                    5 
                  
                   from ryu.base import app_manager 
                  
                   class L2Switch(app_manager.RyuApp): 
                  
                       def __init__(self, *args, **kwargs): 
                  
                           super(L2Switch, self).__init__(*args, **kwargs)

如果你覺得非常熟悉，不要懷疑，我確實是在拿官網的例子再講。

首先，我們從ryu.base import app_manager，在前面我們也提到過這個文件中定義了RyuApp基類。我們在開發APP的時候只需要繼承這個基類，就獲得你想要的一個APP的一切了。於是，我們就不用去注冊了？！是的，不需要了！

保存文件，可以取一個名字為L2Switch.py。

現在你可以運行你的APP了。快得有點不敢相信吧！但是目前什么都沒有，運行之后，馬上就會結束，但起碼我們的代碼沒有報錯。

運行:

 
              Shell 
             
             ryu-manager L2Switch.py 
            
                    1 
                  
                   ryu-manager L2Switch.py

繼續往里面添加內容：

 
              Python 
             
             from ryu.base import app_manager
from ryu.controller import ofp_event
from ryu.controller.handler import MAIN_DISPATCHER
from ryu.controller.handler import set_ev_cls

class L2Switch(app_manager.RyuApp):
    def __init__(self, *args, **kwargs):
        super(L2Switch, self).__init__(*args, **kwargs)

    @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER)
    def packet_in_handler(self, ev):
        msg = ev.msg
        datapath = msg.datapath
        ofp = datapath.ofproto
        ofp_parser = datapath.ofproto_parser

        actions = [ofp_parser.OFPActionOutput(ofp.OFPP_FLOOD)]
        out = ofp_parser.OFPPacketOut(
            datapath=datapath, buffer_id=msg.buffer_id, in_port=msg.in_port,
            actions=actions)
        datapath.send_msg(out) 
            
                    1 
                  
                    2 
                  
                    3 
                  
                    4 
                  
                    5 
                  
                    6 
                  
                    7 
                  
                    8 
                  
                    9 
                  
                    10 
                  
                    11 
                  
                    12 
                  
                    13 
                  
                    14 
                  
                    15 
                  
                    16 
                  
                    17 
                  
                    18 
                  
                    19 
                  
                    20 
                  
                    21 
                  
                   from ryu.base import app_manager 
                  
                   from ryu.controller import ofp_event 
                  
                   from ryu.controller.handler import MAIN_DISPATCHER 
                  
                   from ryu.controller.handler import set_ev_cls 
                  
                   class L2Switch(app_manager.RyuApp): 
                  
                       def __init__(self, *args, **kwargs): 
                  
                           super(L2Switch, self).__init__(*args, **kwargs) 
                  
                       @set_ev_cls(ofp_event.EventOFPPacketIn, MAIN_DISPATCHER) 
                  
                       def packet_in_handler(self, ev): 
                  
                           msg = ev.msg 
                  
                           datapath = msg.datapath 
                  
                           ofp = datapath.ofproto 
                  
                           ofp_parser = datapath.ofproto_parser 
                  
                           actions = [ofp_parser.OFPActionOutput(ofp.OFPP_FLOOD)] 
                  
                           out = ofp_parser.OFPPacketOut( 
                  
                               datapath=datapath, buffer_id=msg.buffer_id, in_port=msg.in_port, 
                  
                               actions=actions) 
                  
                           datapath.send_msg(out)

其中ofp_event完成了事件的定義，從而我們可以在函數中注冊handler，監聽事件，並作出回應。

packet_in_handler方法用於處理packet_in事件。@set_ev_cls修飾符用於告知RYU，被修飾的函數應該被調用。（翻譯得有點爛這句）

set_ev_cls第一個參數表示事件發生時應該調用的函數，第二個參數告訴交換機只有在交換機握手完成之后，才可以被調用。

下面分析具體的數據操作：

ev.msg：每一個事件類ev中都有msg成員，用於攜帶觸發事件的數據包。
msg.datapath：已經格式化的msg其實就是一個packet_in報文，msg.datapath直接可以獲得packet_in報文的datapath結構。datapath用於描述一個交換網橋。也是和控制器通信的實體單元。datapath.send_msg()函數用於發送數據到指定datapath。通過datapath.id可獲得dpid數據，在后續的教程中會有使用。
datapath.ofproto對象是一個OpenFlow協議數據結構的對象，成員包含OpenFlow協議的數據結構，如動作類型OFPP_FLOOD。
datapath.ofp_parser則是一個按照OpenFlow解析的數據結構。
actions是一個列表，用於存放action list，可在其中添加動作。
通過ofp_parser類，可以構造構造packet_out數據結構。括弧中填寫對應字段的賦值即可。

如果datapath.send_msg()函數發送的是一個OpenFlow的數據結構，RYU將把這個數據發送到對應的datapath。

至此，一個簡單的HUB已經完成。

6 RYU進階——二層交換機

在以上的基礎之上，繼續修改就可以完成二層交換機的功能。具體代碼如下：

 
              Python 
             
             import struct
import logging

from ryu.base import app_manager
from ryu.controller import mac_to_port
from ryu.controller import ofp_event
from ryu.controller.handler import MAIN_DISPATCHER
from ryu.controller.handler import set_ev_cls
from ryu.ofproto import ofproto_v1_0
from ryu.lib.mac import haddr_to_bin
from ryu.lib.packet import packet
from ryu.lib.packet import ethernet

class L2Switch(app_manager.RyuApp):

    OFP_VERSIONS = [ofproto_v1_0.OFP_VERSION]#define the version of OpenFlow

    def __init__(self, *args, **kwargs):
        super(L2Switch, self).__init__(*args, **kwargs)
        self.mac_to_port = {}

    def add_flow(self, datapath, in_port, dst, actions):
        ofproto = datapath.ofproto

        match = datapath.ofproto_parser.OFPMatch(
            in_port = in_port, dl_dst = haddr_to_bin(dst))

        mod = datapath.ofproto_parser.OFPFlowMod(
            datapath = datapath, match = match, cookie = 0,
            command = ofproto.OFPFC_ADD, idle_timeout = 10,hard_timeout = 30,
            priority = ofproto.OFP_DEFAULT_PRIORITY,
            flags =ofproto.OFPFF_SEND_FLOW_REM, actions = actions)

        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

        pkt = packet.Packet(msg.data)
        eth = pkt.get_protocol(ethernet.ethernet)

        dst = eth.dst
        src = eth.src

        dpid = datapath.id    #get the dpid
        self.mac_to_port.setdefault(dpid, {})

        self.logger.info("packet in %s %s %s %s", dpid, src, dst , msg.in_port)
        #To learn a mac address to avoid FLOOD next time.

        self.mac_to_port[dpid][src] = msg.in_port

        out_port = ofproto.OFPP_FLOOD

        #Look up the out_port 
        if dst in self.mac_to_port[dpid]:
            out_port = self.mac_to_port[dpid][dst]

        ofp_parser = datapath.ofproto_parser

        actions = [ofp_parser.OFPActionOutput(out_port)]

        if out_port != ofproto.OFPP_FLOOD:
            self.add_flow(datapath, msg.in_port, dst, actions)

        #We always send the packet_out to handle the first packet.
        packet_out = ofp_parser.OFPPacketOut(datapath = datapath, buffer_id = msg.buffer_id,
            in_port = msg.in_port, actions = actions)
        datapath.send_msg(packet_out)
    #To show the message of ports' status.
    @set_ev_cls(ofp_event.EventOFPPortStatus, MAIN_DISPATCHER)
    def _port_status_handler(self, ev):
        msg = ev.msg
        reason = msg.reason
        port_no = msg.desc.port_no

        ofproto = msg.datapath.ofproto

        if reason == ofproto.OFPPR_ADD:
            self.logger.info("port added %s", port_no)
        elif reason == ofproto.OFPPR_DELETE:
            self.logger.info("port deleted %s", port_no)
        elif reason == ofproto.OFPPR_MODIFY:
            self.logger.info("port modified %s", port_no)
        else:
            self.logger.info("Illeagal port state %s %s", port_no, reason) 
            
                    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 
                  
                   import struct 
                  
                   import logging 
                  
                   from ryu.base import app_manager 
                  
                   from ryu.controller import mac_to_port 
                  
                   from ryu.controller import ofp_event 
                  
                   from ryu.controller.handler import MAIN_DISPATCHER 
                  
                   from ryu.controller.handler import set_ev_cls 
                  
                   from ryu.ofproto import ofproto_v1_0 
                  
                   from ryu.lib.mac import haddr_to_bin 
                  
                   from ryu.lib.packet import packet 
                  
                   from ryu.lib.packet import ethernet 
                  
                   class L2Switch(app_manager.RyuApp): 
                  
                       OFP_VERSIONS = [ofproto_v1_0.OFP_VERSION]#define the version of OpenFlow 
                  
                       def __init__(self, *args, **kwargs): 
                  
                           super(L2Switch, self).__init__(*args, **kwargs) 
                  
                           self.mac_to_port = {} 
                  
                       def add_flow(self, datapath, in_port, dst, actions): 
                  
                           ofproto = datapath.ofproto 
                  
                           match = datapath.ofproto_parser.OFPMatch( 
                  
                               in_port = in_port, dl_dst = haddr_to_bin(dst)) 
                  
                           mod = datapath.ofproto_parser.OFPFlowMod( 
                  
                               datapath = datapath, match = match, cookie = 0, 
                  
                               command = ofproto.OFPFC_ADD, idle_timeout = 10,hard_timeout = 30, 
                  
                               priority = ofproto.OFP_DEFAULT_PRIORITY, 
                  
                               flags =ofproto.OFPFF_SEND_FLOW_REM, actions = actions) 
                  
                           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 
                  
                           pkt = packet.Packet(msg.data) 
                  
                           eth = pkt.get_protocol(ethernet.ethernet) 
                  
                           dst = eth.dst 
                  
                           src = eth.src 
                  
                           dpid = datapath.id    #get the dpid 
                  
                           self.mac_to_port.setdefault(dpid, {}) 
                  
                           self.logger.info("packet in %s %s %s %s", dpid, src, dst , msg.in_port) 
                  
                           #To learn a mac address to avoid FLOOD next time. 
                  
                           self.mac_to_port[dpid][src] = msg.in_port 
                  
                           out_port = ofproto.OFPP_FLOOD 
                  
                           #Look up the out_port  
                  
                           if dst in self.mac_to_port[dpid]: 
                  
                               out_port = self.mac_to_port[dpid][dst] 
                  
                           ofp_parser = datapath.ofproto_parser 
                  
                           actions = [ofp_parser.OFPActionOutput(out_port)] 
                  
                           if out_port != ofproto.OFPP_FLOOD: 
                  
                               self.add_flow(datapath, msg.in_port, dst, actions) 
                  
                           #We always send the packet_out to handle the first packet. 
                  
                           packet_out = ofp_parser.OFPPacketOut(datapath = datapath, buffer_id = msg.buffer_id, 
                  
                               in_port = msg.in_port, actions = actions) 
                  
                           datapath.send_msg(packet_out) 
                  
                       #To show the message of ports' status. 
                  
                       @set_ev_cls(ofp_event.EventOFPPortStatus, MAIN_DISPATCHER) 
                  
                       def _port_status_handler(self, ev): 
                  
                           msg = ev.msg 
                  
                           reason = msg.reason 
                  
                           port_no = msg.desc.port_no 
                  
                           ofproto = msg.datapath.ofproto 
                  
                           if reason == ofproto.OFPPR_ADD: 
                  
                               self.logger.info("port added %s", port_no) 
                  
                           elif reason == ofproto.OFPPR_DELETE: 
                  
                               self.logger.info("port deleted %s", port_no) 
                  
                           elif reason == ofproto.OFPPR_MODIFY: 
                  
                               self.logger.info("port modified %s", port_no) 
                  
                           else: 
                  
                               self.logger.info("Illeagal port state %s %s", port_no, reason)

相信代碼中的注釋已經足以讓讀者理解這個程序。完成之后，運行:

 
              Shell 
             
             ryu-manager L2Switch.py 
            
                    1 
                  
                   ryu-manager L2Switch.py

然后可以使用Mininet進行pingall測試，成功！

7 后語

習慣性還是寫一寫總結。RYU的方便簡潔大大超出我的預料，比我使用過的任何一個控制器都要易於使用和開發。這些是我學RYU一兩天的收獲，希望在后續的學習中還能有所收獲，寫出更好的博文。如果你有什么意見或建議可以評論，相互學習，共同進步。

最后提供一些有用的鏈接：
（1）http://osrg.github.io/ryu/resources.html
我比較喜歡里里面的 http://ryu.readthedocs.org/en/latest/
當然里面的電子書也是相當好的：http://osrg.github.io/ryu-book/en/html/
（2）推薦一個小伙伴的博客：linton.tw
他在RYU上有更多的學習和研究。歡迎訪問！

轉載自：李呈博客@李呈，http://www.muzixing.com/pages/2014/09/20/ryuru-men-jiao-cheng.html

Ryu

What's Ryu?

實戰錄 | 絕對干貨！SDN controller Ryu答

1 前言

2 RYU的安裝

3 RYU使用

4 RYU源碼分析

base

controller

lib

ofproto

topology

contrib

cmd

services

tests

5 開發你自己的RYU應用程序

6 RYU進階——二層交換機

7 后語

免責聲明！