openstack/deb-ryu
Code Issues Proposed changes

test: simplify integrated OVS test suite

Browse Source 
This patch simplifies integrated OVS test suite. Currently, we wait
for a barrier response before moving to the next test. However, we
don't need. The logic works like the following:

sending a flow mod (deleting all the flows)
sending a barrier
sending a flow mod (set up a flow to test)
sending a barrier
sending a flow stats

Then the reply handler for flow stats verifies the result and move to
the next.

You can run a test suite like:

$ ryu-manager ~/git/ryu/ryu/tests/integrated/test_add_flow_v12_actions.py

We can try two more suites:

ryu/tests/integrated/test_add_flow_v10.py
ryu/tests/integrated/test_add_flow_v12_matches.py

Signed-off-by: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
This commit is contained in:
FUJITA Tomonori 2012-07-28 10:24:46 +09:00
parent dfa4ab185a
commit 8c1978942d
5 changed files with 1041 additions and 3279 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
bin/ryu-manager
View File

@ -32,7 +32,6 @@ from ryu import utils
from ryu.app import wsgi from ryu.app import wsgi
from ryu.base.app_manager import AppManager from ryu.base.app_manager import AppManager
from ryu.controller import controller from ryu.controller import controller
from ryu.tests.integrated import tester
FLAGS = gflags.FLAGS FLAGS = gflags.FLAGS

814
ryu/tests/integrated/test_add_flow_v10.py
View File

@ -17,691 +17,245 @@
import logging import logging
from ryu.controller import handler
from ryu.controller.handler import set_ev_cls
from ryu.tests.integrated import tester from ryu.tests.integrated import tester
from ryu.ofproto import nx_match from ryu.ofproto import nx_match
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
_target = 'br-tester'
class RunTest(tester.TestFlowBase):
""" Test case for add flows of1.0
"""
class RunTest(tester.RunTestBase): def __init__(self, *args, **kwargs):
super(RunTest, self).__init__(*args, **kwargs)
self._verify = []
def __init__(self): def add_action(self, dp, action):
super(RunTest, self).__init__() rule = nx_match.ClsRule()
self.send_flow_mod(
dp, rule, 0, dp.ofproto.OFPFC_ADD, 0, 0, None,
0xffffffff, None, dp.ofproto.OFPFF_SEND_FLOW_REM, action)
def send_flow_mod(self, rule, cookie, command, idle_timeout, hard_timeout, def add_rule(self, dp, rule):
priority=None, buffer_id=0xffffffff, self.send_flow_mod(
dp, rule, 0, dp.ofproto.OFPFC_ADD, 0, 0, None,
0xffffffff, None, dp.ofproto.OFPFF_SEND_FLOW_REM, [])
def send_flow_mod(self, dp, rule, cookie, command, idle_timeout,
hard_timeout, priority=None, buffer_id=0xffffffff,
out_port=None, flags=0, actions=None): out_port=None, flags=0, actions=None):
if priority is None: if priority is None:
priority = self.ofproto.OFP_DEFAULT_PRIORITY priority = dp.ofproto.OFP_DEFAULT_PRIORITY
if out_port is None: if out_port is None:
out_port = self.ofproto.OFPP_NONE out_port = dp.ofproto.OFPP_NONE
match_tuple = rule.match_tuple() match_tuple = rule.match_tuple()
match = self.ofproto_parser.OFPMatch(*match_tuple) match = dp.ofproto_parser.OFPMatch(*match_tuple)
flow_mod = self.ofproto_parser.OFPFlowMod(
self.datapath, match, cookie, command, idle_timeout, hard_timeout, m = dp.ofproto_parser.OFPFlowMod(
dp, match, cookie, command, idle_timeout, hard_timeout,
priority, buffer_id, out_port, flags, actions) priority, buffer_id, out_port, flags, actions)
self.datapath.send_msg(flow_mod) dp.send_msg(m)
def test_action_output(self): def _verify_action(self, actions, type_, name, value):
datapath = self.datapath try:
ofproto = self.ofproto action = actions[0]
if action.cls_action_type != type_:
return "Action type error. send:%s, val:%s" \
% (type_, action.cls_action_type)
except IndexError:
return "Action is not setting."
f_value = None
if name:
try:
if isinstance(name, list):
f_value = [getattr(action, n) for n in name]
else:
f_value = getattr(action, name)
except AttributeError:
pass
if f_value != value:
return "Value error. send:%s=%s val:%s" \
% (name, value, f_value)
return True
def _verify_rule(self, rule, name, value):
f_value = getattr(rule, name)
if f_value != value:
return "Value error. send:%s=%s val:%s" \
% (name, value, f_value)
return True
def verify_default(self, dp, stats):
verify = self._verify
self._verify = []
match = stats[0].match
actions = stats[0].actions
if len(verify) == 2:
return self._verify_rule(match, *verify)
elif len(verify) == 3:
return self._verify_action(actions, *verify)
else:
return "self._verify is invalid."
# Test of Actions
def test_action_output(self, dp):
out_port = 2 out_port = 2
self.set_val('out_port', out_port) self._verify = [dp.ofproto.OFPAT_OUTPUT,
'port', out_port]
actions = [ action = dp.ofproto_parser.OFPActionOutput(out_port)
datapath.ofproto_parser.OFPActionOutput(out_port), self.add_action(dp, [action, ])
]
rule = nx_match.ClsRule()
self.send_flow_mod(
rule=rule, cookie=0, command=ofproto.OFPFC_ADD,
idle_timeout=0, hard_timeout=0,
priority=ofproto.OFP_DEFAULT_PRIORITY,
flags=ofproto.OFPFF_SEND_FLOW_REM, actions=actions)
def check_action_output(self):
ovs_actions = {}
out_port = self.get_val('out_port')
try:
ovs_actions = self.get_ovs_flows(_target)[0]['actions']
ovs_out_port = ovs_actions['output']
except (KeyError, IndexError):
ovs_out_port = ''
if ovs_out_port == '' or int(ovs_out_port) != out_port:
err = 'send_actions=[output:%s] ovs_actions=[%s]' \
% (out_port, self.cnv_txt(ovs_actions))
self.results(ret=False, msg=err)
return
self.results()
def test_action_vlan_vid(self):
datapath = self.datapath
ofproto = self.ofproto
vlan_vid = 3
self.set_val('vlan_vid', vlan_vid)
actions = [
datapath.ofproto_parser.OFPActionVlanVid(vlan_vid),
]
rule = nx_match.ClsRule()
self.send_flow_mod(
rule=rule, cookie=0, command=ofproto.OFPFC_ADD,
idle_timeout=0, hard_timeout=0,
priority=ofproto.OFP_DEFAULT_PRIORITY,
flags=ofproto.OFPFF_SEND_FLOW_REM, actions=actions)
def check_action_vlan_vid(self):
ovs_actions = {}
vlan_vid = self.get_val('vlan_vid')
try:
ovs_actions = self.get_ovs_flows(_target)[0]['actions']
ovs_vlan_vid = ovs_actions['mod_vlan_vid']
except (KeyError, IndexError):
ovs_vlan_vid = ''
if ovs_vlan_vid == '' or int(ovs_vlan_vid) != vlan_vid:
err = 'send_actions=[vlan_vid:%s] ovs_actions=[%s]' \
% (vlan_vid, self.cnv_txt(ovs_actions))
self.results(ret=False, msg=err)
return
self.results()
def test_action_vlan_pcp(self):
datapath = self.datapath
ofproto = self.ofproto
vlan_pcp = 4
self.set_val('vlan_pcp', vlan_pcp)
actions = [
datapath.ofproto_parser.OFPActionVlanPcp(vlan_pcp),
]
rule = nx_match.ClsRule()
self.send_flow_mod(
rule=rule, cookie=0, command=ofproto.OFPFC_ADD,
idle_timeout=0, hard_timeout=0,
priority=ofproto.OFP_DEFAULT_PRIORITY,
flags=ofproto.OFPFF_SEND_FLOW_REM, actions=actions)
def check_action_vlan_pcp(self):
ovs_actions = {}
vlan_pcp = self.get_val('vlan_pcp')
try:
ovs_actions = self.get_ovs_flows(_target)[0]['actions']
ovs_vlan_pcp = ovs_actions['mod_vlan_pcp']
except (KeyError, IndexError):
ovs_vlan_pcp = ''
if ovs_vlan_pcp == '' or int(ovs_vlan_pcp) != vlan_pcp:
err = 'send_actions=[vlan_vid:%s] ovs_actions=[%s]' \
% (vlan_pcp, self.cnv_txt(ovs_actions))
self.results(ret=False, msg=err)
return
self.results()
def test_action_strip_vlan(self):
datapath = self.datapath
ofproto = self.ofproto
actions = [
datapath.ofproto_parser.OFPActionStripVlan(),
]
rule = nx_match.ClsRule()
self.send_flow_mod(
rule=rule, cookie=0, command=ofproto.OFPFC_ADD,
idle_timeout=0, hard_timeout=0,
priority=ofproto.OFP_DEFAULT_PRIORITY,
flags=ofproto.OFPFF_SEND_FLOW_REM, actions=actions)
def check_action_strip_vlan(self):
ovs_actions = {}
try:
ovs_actions = self.get_ovs_flows(_target)[0]['actions']
except (KeyError, IndexError):
pass
if not 'strip_vlan' in ovs_actions:
err = 'send_actions=[strip_vlan] ovs_actions=[%s]' \
% (self.cnv_txt(ovs_actions))
self.results(ret=False, msg=err)
return
self.results()
def test_action_set_dl_src(self):
datapath = self.datapath
ofproto = self.ofproto
dl_src = '56:b3:42:04:b2:7a'
self.set_val('dl_src', dl_src)
dl_src_bin = self.haddr_to_bin(dl_src)
actions = [
datapath.ofproto_parser.OFPActionSetDlSrc(dl_src_bin),
]
rule = nx_match.ClsRule()
self.send_flow_mod(
rule=rule, cookie=0, command=ofproto.OFPFC_ADD,
idle_timeout=0, hard_timeout=0,
priority=ofproto.OFP_DEFAULT_PRIORITY,
flags=ofproto.OFPFF_SEND_FLOW_REM, actions=actions)
def check_action_set_dl_src(self):
ovs_actions = {}
dl_src = self.get_val('dl_src')
try:
ovs_actions = self.get_ovs_flows(_target)[0]['actions']
ovs_dl_src = ovs_actions['mod_dl_src']
except (KeyError, IndexError):
ovs_dl_src = ''
if ovs_dl_src == '' or ovs_dl_src != dl_src:
err = 'send_actions=[dl_src:%s] ovs_actions=[%s]' \
% (dl_src, self.cnv_txt(ovs_actions))
self.results(ret=False, msg=err)
return
self.results()
def test_action_set_dl_dst(self):
datapath = self.datapath
ofproto = self.ofproto
dl_dst = 'c2:93:a2:fb:d0:f4'
self.set_val('dl_dst', dl_dst)
dl_dst_bin = self.haddr_to_bin(dl_dst)
actions = [
datapath.ofproto_parser.OFPActionSetDlDst(dl_dst_bin),
]
rule = nx_match.ClsRule()
self.send_flow_mod(
rule=rule, cookie=0, command=ofproto.OFPFC_ADD,
idle_timeout=0, hard_timeout=0,
priority=ofproto.OFP_DEFAULT_PRIORITY,
flags=ofproto.OFPFF_SEND_FLOW_REM, actions=actions)
def check_action_set_dl_dst(self):
ovs_actions = {}
dl_dst = self.get_val('dl_dst')
try:
ovs_actions = self.get_ovs_flows(_target)[0]['actions']
ovs_dl_dst = ovs_actions['mod_dl_dst']
except (KeyError, IndexError):
ovs_dl_dst = ''
if ovs_dl_dst == '' or ovs_dl_dst != dl_dst:
err = 'send_actions=[dl_dst:%s] ovs_actions=[%s]' \
% (dl_dst, self.cnv_txt(ovs_actions))
self.results(ret=False, msg=err)
return
self.results()
def test_action_set_nw_src(self):
datapath = self.datapath
ofproto = self.ofproto
nw_src = '216.132.81.105'
self.set_val('nw_src', nw_src)
nw_src_int = self.ipv4_to_int(nw_src)
actions = [
datapath.ofproto_parser.OFPActionSetNwSrc(nw_src_int),
]
rule = nx_match.ClsRule()
self.send_flow_mod(
rule=rule, cookie=0, command=ofproto.OFPFC_ADD,
idle_timeout=0, hard_timeout=0,
priority=ofproto.OFP_DEFAULT_PRIORITY,
flags=ofproto.OFPFF_SEND_FLOW_REM, actions=actions)
def check_action_set_nw_src(self):
ovs_actions = {}
nw_src = self.get_val('nw_src')
try:
ovs_actions = self.get_ovs_flows(_target)[0]['actions']
ovs_nw_src = ovs_actions['mod_nw_src']
except (KeyError, IndexError):
ovs_nw_src = ''
if ovs_nw_src == '' or ovs_nw_src != nw_src:
err = 'send_actions=[nw_src:%s] ovs_actions=[%s]' \
% (nw_src, self.cnv_txt(ovs_actions))
self.results(ret=False, msg=err)
return
self.results()
def test_action_set_nw_dst(self):
datapath = self.datapath
ofproto = self.ofproto
nw_dst = '223.201.206.3'
self.set_val('nw_dst', nw_dst)
nw_dst_int = self.ipv4_to_int(nw_dst)
actions = [
datapath.ofproto_parser.OFPActionSetNwDst(nw_dst_int),
]
rule = nx_match.ClsRule()
self.send_flow_mod(
rule=rule, cookie=0, command=ofproto.OFPFC_ADD,
idle_timeout=0, hard_timeout=0,
priority=ofproto.OFP_DEFAULT_PRIORITY,
flags=ofproto.OFPFF_SEND_FLOW_REM, actions=actions)
def check_action_set_nw_dst(self):
ovs_actions = {}
nw_dst = self.get_val('nw_dst')
try:
ovs_actions = self.get_ovs_flows(_target)[0]['actions']
ovs_nw_dst = ovs_actions['mod_nw_dst']
except (KeyError, IndexError):
ovs_nw_dst = ''
if ovs_nw_dst == '' or ovs_nw_dst != nw_dst:
err = 'send_actions=[nw_dst:%s] ovs_actions=[%s]' \
% (nw_dst, self.cnv_txt(ovs_actions))
self.results(ret=False, msg=err)
return
self.results()
def test_action_set_nw_tos(self):
datapath = self.datapath
ofproto = self.ofproto
nw_tos = 111
self.set_val('nw_tos', nw_tos)
actions = [
datapath.ofproto_parser.OFPActionSetNwTos(nw_tos),
]
rule = nx_match.ClsRule()
self.send_flow_mod(
rule=rule, cookie=0, command=ofproto.OFPFC_ADD,
idle_timeout=0, hard_timeout=0,
priority=ofproto.OFP_DEFAULT_PRIORITY,
flags=ofproto.OFPFF_SEND_FLOW_REM, actions=actions)
def check_action_set_nw_tos(self):
ovs_actions = {}
nw_tos = self.get_val('nw_tos')
try:
ovs_actions = self.get_ovs_flows(_target)[0]['actions']
ovs_nw_tos = ovs_actions['mod_nw_tos']
except (KeyError, IndexError):
ovs_nw_tos = ''
if ovs_nw_tos == '' or int(ovs_nw_tos) != nw_tos:
err = 'send_actions=[nw_tos:%s] ovs_actions=[%s]' \
% (nw_tos, self.cnv_txt(ovs_actions))
self.results(ret=False, msg=err)
return
self.results()
def test_action_set_tp_src(self):
datapath = self.datapath
ofproto = self.ofproto
tp_src = 55420
self.set_val('tp_src', tp_src)
actions = [
datapath.ofproto_parser.OFPActionSetTpSrc(tp_src),
]
rule = nx_match.ClsRule()
self.send_flow_mod(
rule=rule, cookie=0, command=ofproto.OFPFC_ADD,
idle_timeout=0, hard_timeout=0,
priority=ofproto.OFP_DEFAULT_PRIORITY,
flags=ofproto.OFPFF_SEND_FLOW_REM, actions=actions)
def check_action_set_tp_src(self):
ovs_actions = {}
tp_src = self.get_val('tp_src')
try:
ovs_actions = self.get_ovs_flows(_target)[0]['actions']
ovs_tp_src = ovs_actions['mod_tp_src']
except (KeyError, IndexError):
ovs_tp_src = ''
if ovs_tp_src == '' or int(ovs_tp_src) != tp_src:
err = 'send_actions=[tp_src:%s] ovs_actions=[%s]' \
% (tp_src, self.cnv_txt(ovs_actions))
self.results(ret=False, msg=err)
return
self.results()
def test_action_set_tp_dst(self):
datapath = self.datapath
ofproto = self.ofproto
tp_dst = 15430
self.set_val('tp_dst', tp_dst)
actions = [
datapath.ofproto_parser.OFPActionSetTpDst(tp_dst),
]
rule = nx_match.ClsRule()
self.send_flow_mod(
rule=rule, cookie=0, command=ofproto.OFPFC_ADD,
idle_timeout=0, hard_timeout=0,
priority=ofproto.OFP_DEFAULT_PRIORITY,
flags=ofproto.OFPFF_SEND_FLOW_REM, actions=actions)
def check_action_set_tp_dst(self):
ovs_actions = {}
tp_dst = self.get_val('tp_dst')
try:
ovs_actions = self.get_ovs_flows(_target)[0]['actions']
ovs_tp_dst = ovs_actions['mod_tp_dst']
except (KeyError, IndexError):
ovs_tp_dst = ''
if ovs_tp_dst == '' or int(ovs_tp_dst) != tp_dst:
err = 'send_actions=[tp_src:%s] ovs_actions=[%s]' \
% (tp_dst, self.cnv_txt(ovs_actions))
self.results(ret=False, msg=err)
return
self.results()
def test_action_enqueue(self):
datapath = self.datapath
ofproto = self.ofproto
port = 207
queue_id = 4287508753
self.set_val('enqueue', str(port) + 'q' + str(queue_id))
actions = [
datapath.ofproto_parser.OFPActionEnqueue(port, queue_id),
]
rule = nx_match.ClsRule()
self.send_flow_mod(
rule=rule, cookie=0, command=ofproto.OFPFC_ADD,
idle_timeout=0, hard_timeout=0,
priority=ofproto.OFP_DEFAULT_PRIORITY,
flags=ofproto.OFPFF_SEND_FLOW_REM, actions=actions)
def check_action_enqueue(self):
ovs_actions = {}
enqueue = self.get_val('enqueue')
try:
ovs_actions = self.get_ovs_flows(_target)[0]['actions']
ovs_enqueue = ovs_actions['enqueue']
except (KeyError, IndexError):
ovs_enqueue = ''
if ovs_enqueue == '' or ovs_enqueue != enqueue:
err = 'send_actions=[enqueue:%s] ovs_actions=[%s]' \
% (enqueue, self.cnv_txt(ovs_actions))
self.results(ret=False, msg=err)
return
self.results()
def test_rule_set_in_port(self):
datapath = self.datapath
ofproto = self.ofproto
def test_rule_set_in_port(self, dp):
in_port = 32 in_port = 32
self.set_val('in_port', in_port) self._verify = ['in_port', in_port]
actions = []
rule = nx_match.ClsRule() rule = nx_match.ClsRule()
rule.set_in_port(in_port) rule.set_in_port(in_port)
self.send_flow_mod( self.add_rule(dp, rule)
rule=rule, cookie=0, command=ofproto.OFPFC_ADD,
idle_timeout=0, hard_timeout=0,
priority=ofproto.OFP_DEFAULT_PRIORITY,
flags=ofproto.OFPFF_SEND_FLOW_REM, actions=actions)
def check_rule_set_in_port(self): def test_action_vlan_vid(self, dp):
ovs_rules = {} vlan_vid = 2
in_port = self.get_val('in_port') self._verify = [dp.ofproto.OFPAT_SET_VLAN_VID,
'vlan_vid', vlan_vid]
action = dp.ofproto_parser.OFPActionVlanVid(vlan_vid)
self.add_action(dp, [action, ])
try: def test_action_vlan_pcp(self, dp):
ovs_rules = self.get_ovs_flows(_target)[0]['rules'] vlan_pcp = 4
ovs_in_port = ovs_rules['in_port'] self._verify = [dp.ofproto.OFPAT_SET_VLAN_PCP,
except (KeyError, IndexError): 'vlan_pcp', vlan_pcp]
ovs_in_port = '' action = dp.ofproto_parser.OFPActionVlanPcp(vlan_pcp)
self.add_action(dp, [action, ])
if ovs_in_port == '' or int(ovs_in_port) != in_port: def test_action_strip_vlan(self, dp):
err = 'send_rules=[in_port:%s] ovs_rules=[%s]' \ vlan_pcp = 4
% (in_port, self.cnv_txt(ovs_rules)) self._verify = [dp.ofproto.OFPAT_STRIP_VLAN,
self.results(ret=False, msg=err) None, None]
return action = dp.ofproto_parser.OFPActionStripVlan()
self.results() self.add_action(dp, [action, ])
def test_rule_set_dl_src(self):
datapath = self.datapath
ofproto = self.ofproto
dl_src = 'b8:a1:94:51:78:83'
self.set_val('dl_src', dl_src)
def test_action_set_dl_src(self, dp):
dl_src = '56:b3:42:04:b2:7a'
dl_src_bin = self.haddr_to_bin(dl_src) dl_src_bin = self.haddr_to_bin(dl_src)
self._verify = [dp.ofproto.OFPAT_SET_DL_SRC,
'dl_addr', dl_src_bin]
action = dp.ofproto_parser.OFPActionSetDlSrc(dl_src_bin)
self.add_action(dp, [action, ])
def test_action_set_dl_dst(self, dp):
dl_dst = 'c2:93:a2:fb:d0:f4'
dl_dst_bin = self.haddr_to_bin(dl_dst)
self._verify = [dp.ofproto.OFPAT_SET_DL_DST,
'dl_addr', dl_dst_bin]
action = dp.ofproto_parser.OFPActionSetDlDst(dl_dst_bin)
self.add_action(dp, [action, ])
def test_action_set_nw_src(self, dp):
nw_src = '216.132.81.105'
nw_src_int = self.ipv4_to_int(nw_src)
self._verify = [dp.ofproto.OFPAT_SET_NW_SRC,
'nw_addr', nw_src_int]
action = dp.ofproto_parser.OFPActionSetNwSrc(nw_src_int)
self.add_action(dp, [action, ])
def test_action_set_nw_dst(self, dp):
nw_dst = '223.201.206.3'
nw_dst_int = self.ipv4_to_int(nw_dst)
self._verify = [dp.ofproto.OFPAT_SET_NW_DST,
'nw_addr', nw_dst_int]
action = dp.ofproto_parser.OFPActionSetNwDst(nw_dst_int)
self.add_action(dp, [action, ])
def test_action_set_nw_tos(self, dp):
nw_tos = 111
self._verify = [dp.ofproto.OFPAT_SET_NW_TOS,
'tos', nw_tos]
action = dp.ofproto_parser.OFPActionSetNwTos(nw_tos)
self.add_action(dp, [action, ])
def test_action_set_tp_src(self, dp):
tp_src = 55420
self._verify = [dp.ofproto.OFPAT_SET_TP_SRC,
'tp', tp_src]
action = dp.ofproto_parser.OFPActionSetTpSrc(tp_src)
self.add_action(dp, [action, ])
def test_action_set_tp_dst(self, dp):
tp_dst = 15430
self._verify = [dp.ofproto.OFPAT_SET_TP_DST,
'tp', tp_dst]
action = dp.ofproto_parser.OFPActionSetTpDst(tp_dst)
self.add_action(dp, [action, ])
def test_action_enqueue(self, dp):
port = 207
queue_id = 4287508753
self._verify = [dp.ofproto.OFPAT_ENQUEUE,
['port', 'queue_id'], [port, queue_id]]
action = dp.ofproto_parser.OFPActionEnqueue(port, queue_id)
self.add_action(dp, [action, ])
# Test of Rules
def test_rule_set_in_port(self, dp):
in_port = 32
self._verify = ['in_port', in_port]
rule = nx_match.ClsRule()
rule.set_in_port(in_port)
self.add_rule(dp, rule)
def test_rule_set_dl_src(self, dp):
dl_src = 'b8:a1:94:51:78:83'
dl_src_bin = self.haddr_to_bin(dl_src)
self._verify = ['dl_src', dl_src_bin]
actions = []
rule = nx_match.ClsRule() rule = nx_match.ClsRule()
rule.set_dl_src(dl_src_bin) rule.set_dl_src(dl_src_bin)
self.add_rule(dp, rule)
self.send_flow_mod( def test_rule_set_dl_type_ip(self, dp):
rule=rule, cookie=0, command=ofproto.OFPFC_ADD,
idle_timeout=0, hard_timeout=0,
priority=ofproto.OFP_DEFAULT_PRIORITY,
flags=ofproto.OFPFF_SEND_FLOW_REM, actions=actions)
def check_rule_set_dl_src(self):
ovs_rules = {}
dl_src = self.get_val('dl_src')
try:
ovs_rules = self.get_ovs_flows(_target)[0]['rules']
ovs_dl_src = ovs_rules['dl_src']
except (KeyError, IndexError):
ovs_dl_src = ''
if ovs_dl_src == '' or ovs_dl_src != dl_src:
err = 'send_rules=[dl_src:%s] ovs_rules=[%s]' \
% (dl_src, self.cnv_txt(ovs_rules))
self.results(ret=False, msg=err)
return
self.results()
def test_rule_set_dl_type_ip(self):
datapath = self.datapath
ofproto = self.ofproto
dl_type = nx_match.ETH_TYPE_IP dl_type = nx_match.ETH_TYPE_IP
self.set_val('dl_type', 'ip') self._verify = ['dl_type', dl_type]
actions = []
rule = nx_match.ClsRule() rule = nx_match.ClsRule()
rule.set_dl_type(dl_type) rule.set_dl_type(dl_type)
self.add_rule(dp, rule)
self.send_flow_mod( def test_rule_set_dl_type_arp(self, dp):
rule=rule, cookie=0, command=ofproto.OFPFC_ADD,
idle_timeout=0, hard_timeout=0,
priority=ofproto.OFP_DEFAULT_PRIORITY,
flags=ofproto.OFPFF_SEND_FLOW_REM, actions=actions)
def check_rule_set_dl_type_ip(self):
ovs_rules = {}
dl_type = self.get_val('dl_type')
try:
ovs_rules = self.get_ovs_flows(_target)[0]['rules']
except (KeyError, IndexError):
pass
if not dl_type in ovs_rules:
err = 'send_rules=[dl_type:%s] ovs_rules=[%s]' \
% (dl_type, self.cnv_txt(ovs_rules))
self.results(ret=False, msg=err)
return
self.results()
def test_rule_set_dl_type_arp(self):
datapath = self.datapath
ofproto = self.ofproto
dl_type = nx_match.ETH_TYPE_ARP dl_type = nx_match.ETH_TYPE_ARP
self.set_val('dl_type', 'arp') self._verify = ['dl_type', dl_type]
actions = []
rule = nx_match.ClsRule() rule = nx_match.ClsRule()
rule.set_dl_type(dl_type) rule.set_dl_type(dl_type)
self.add_rule(dp, rule)
self.send_flow_mod( def test_rule_set_dl_type_vlan(self, dp):
rule=rule, cookie=0, command=ofproto.OFPFC_ADD,
idle_timeout=0, hard_timeout=0,
priority=ofproto.OFP_DEFAULT_PRIORITY,
flags=ofproto.OFPFF_SEND_FLOW_REM, actions=actions)
def check_rule_set_dl_type_arp(self):
ovs_rules = {}
dl_type = self.get_val('dl_type')
try:
ovs_rules = self.get_ovs_flows(_target)[0]['rules']
except (KeyError, IndexError):
pass
if not dl_type in ovs_rules:
err = 'send_rules=[dl_type:%s] ovs_rules=[%s]' \
% (dl_type, self.cnv_txt(ovs_rules))
self.results(ret=False, msg=err)
return
self.results()
def test_rule_set_dl_type_vlan(self):
datapath = self.datapath
ofproto = self.ofproto
dl_type = nx_match.ETH_TYPE_VLAN dl_type = nx_match.ETH_TYPE_VLAN
self.set_val('dl_type', nx_match.ETH_TYPE_VLAN) self._verify = ['dl_type', dl_type]
actions = []
rule = nx_match.ClsRule() rule = nx_match.ClsRule()
rule.set_dl_type(dl_type) rule.set_dl_type(dl_type)
self.add_rule(dp, rule)
self.send_flow_mod( def test_rule_set_dl_type_ipv6(self, dp):
rule=rule, cookie=0, command=ofproto.OFPFC_ADD,
idle_timeout=0, hard_timeout=0,
priority=ofproto.OFP_DEFAULT_PRIORITY,
flags=ofproto.OFPFF_SEND_FLOW_REM, actions=actions)
def check_rule_set_dl_type_vlan(self):
ovs_rules = {}
dl_type = self.get_val('dl_type')
try:
ovs_rules = self.get_ovs_flows(_target)[0]['rules']
ovs_dl_type = ovs_rules['dl_type']
except (KeyError, IndexError):
ovs_dl_type = ''
if ovs_dl_type == '' or int(ovs_dl_type, 16) != dl_type:
err = 'send_rules=[dl_src:%s] ovs_rules=[%s]' \
% (dl_type, self.cnv_txt(ovs_rules))
self.results(ret=False, msg=err)
return
self.results()
def test_rule_set_dl_type_ipv6(self):
datapath = self.datapath
ofproto = self.ofproto
dl_type = nx_match.ETH_TYPE_IPV6 dl_type = nx_match.ETH_TYPE_IPV6
self.set_val('dl_type', 'ipv6') self._verify = ['dl_type', dl_type]
actions = []
rule = nx_match.ClsRule() rule = nx_match.ClsRule()
rule.set_dl_type(dl_type) rule.set_dl_type(dl_type)
self.add_rule(dp, rule)
self.send_flow_mod( def test_rule_set_dl_type_lacp(self, dp):
rule=rule, cookie=0, command=ofproto.OFPFC_ADD,
idle_timeout=0, hard_timeout=0,
priority=ofproto.OFP_DEFAULT_PRIORITY,
flags=ofproto.OFPFF_SEND_FLOW_REM, actions=actions)
def check_rule_set_dl_type_ipv6(self):
ovs_rules = {}
dl_type = self.get_val('dl_type')
try:
ovs_rules = self.get_ovs_flows(_target)[0]['rules']
except (KeyError, IndexError):
pass
if not dl_type in ovs_rules:
err = 'send_rules=[dl_type:%s] ovs_rules=[%s]' \
% (dl_type, self.cnv_txt(ovs_rules))
self.results(ret=False, msg=err)
return
self.results()
def test_rule_set_dl_type_lacp(self):
datapath = self.datapath
ofproto = self.ofproto
dl_type = nx_match.ETH_TYPE_LACP dl_type = nx_match.ETH_TYPE_LACP
self.set_val('dl_type', nx_match.ETH_TYPE_LACP) self._verify = ['dl_type', dl_type]
actions = []
rule = nx_match.ClsRule() rule = nx_match.ClsRule()
rule.set_dl_type(dl_type) rule.set_dl_type(dl_type)
self.add_rule(dp, rule)
self.send_flow_mod(
rule=rule, cookie=0, command=ofproto.OFPFC_ADD,
idle_timeout=0, hard_timeout=0,
priority=ofproto.OFP_DEFAULT_PRIORITY,
flags=ofproto.OFPFF_SEND_FLOW_REM, actions=actions)
def check_rule_set_dl_type_lacp(self):
ovs_rules = {}
dl_type = self.get_val('dl_type')
try:
ovs_rules = self.get_ovs_flows(_target)[0]['rules']
ovs_dl_type = ovs_rules['dl_type']
except (KeyError, IndexError):
ovs_dl_type = ''
if ovs_dl_type == '' or int(ovs_dl_type, 16) != dl_type:
err = 'send_rules=[dl_src:%s] ovs_rules=[%s]' \
% (dl_type, self.cnv_txt(ovs_rules))
self.results(ret=False, msg=err)
return
self.results()

1158
ryu/tests/integrated/test_add_flow_v12_actions.py
View File

File diff suppressed because it is too large Load Diff

1987
ryu/tests/integrated/test_add_flow_v12_matches.py
View File

File diff suppressed because it is too large Load Diff

360
ryu/tests/integrated/tester.py
View File

@ -16,319 +16,145 @@
# vim: tabstop=4 shiftwidth=4 softtabstop=4 # vim: tabstop=4 shiftwidth=4 softtabstop=4
import sys import sys
import gflags
import logging import logging
import subprocess
import traceback
from ryu import utils from ryu import utils
from ryu.lib import mac from ryu.lib import mac
from ryu.base import app_manager from ryu.base import app_manager
from ryu.controller import ofp_event from ryu.controller import ofp_event
from ryu.controller import dispatcher
from ryu.controller import event
from ryu.controller import handler from ryu.controller import handler
from ryu.controller import dpset
from ryu.controller.handler import MAIN_DISPATCHER from ryu.controller.handler import MAIN_DISPATCHER
from ryu.controller.handler import CONFIG_DISPATCHER from ryu.controller.handler import CONFIG_DISPATCHER
from ryu.controller.handler import set_ev_cls from ryu.controller.handler import set_ev_cls
from ryu.ofproto import nx_match
from ryu.ofproto import ofproto_v1_0 from ryu.ofproto import ofproto_v1_0
from ryu.ofproto import ofproto_v1_2 from ryu.ofproto import ofproto_v1_2
LOG = logging.getLogger(__name__) LOG = logging.getLogger(__name__)
FLAGS = gflags.FLAGS
gflags.DEFINE_string('run_test_mod', '', 'Test run the module name.')
class EventRunTest(event.EventBase):
def __init__(self, datapath):
super(EventRunTest, self).__init__()
self.datapath = datapath
QUEUE_NAME_RUN_TEST_EV = 'run_test_event'
DISPATCHER_NAME_RUN_TEST_EV = 'run_test_event'
RUN_TEST_EV_DISPATCHER = dispatcher.EventDispatcher(
DISPATCHER_NAME_RUN_TEST_EV)
LOG_TEST_START = 'TEST_START: %s' LOG_TEST_START = 'TEST_START: %s'
LOG_TEST_RESULTS = 'TEST_RESULTS:' LOG_TEST_RESULTS = 'TEST_RESULTS:'
LOG_TEST_FINISH = 'TEST_FINISHED: Completed=[%s], OK=[%s], NG=[%s]' LOG_TEST_FINISH = 'TEST_FINISHED: Completed=[%s]'
class Tester(app_manager.RyuApp): class TestFlowBase(app_manager.RyuApp):
def __init__(self, *args, **kwargs):
super(Tester, self).__init__()
self.ev_q = dispatcher.EventQueue(QUEUE_NAME_RUN_TEST_EV,
RUN_TEST_EV_DISPATCHER)
run_test_mod = utils.import_module(FLAGS.run_test_mod)
LOG.debug('import run_test_mod.[%s]', run_test_mod.__name__)
self.run_test = run_test_mod.RunTest(*args, **kwargs)
handler.register_instance(self.run_test)
@set_ev_cls(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)
def switch_features_handler(self, ev):
msg = ev.msg
datapath = msg.datapath
send_delete_all_flows(datapath)
datapath.send_barrier()
@set_ev_cls(ofp_event.EventOFPBarrierReply, MAIN_DISPATCHER)
def barrier_replay_handler(self, ev):
self.ev_q.queue(EventRunTest(ev.msg.datapath))
@set_ev_cls(EventRunTest, RUN_TEST_EV_DISPATCHER)
def run_test_halder(self, ev):
dp = ev.datapath
t = self.run_test
if not t._test_started():
t._test_init(dp)
if not self._run_test(t):
# run_test was throwing exception.
LOG.info(LOG_TEST_FINISH, False, t._RESULTS_OK, t._RESULTS_NG)
return
if not t._test_completed():
t.datapath.send_barrier()
return
# Completed all tests.
LOG.info(LOG_TEST_FINISH, True, t._RESULTS_OK, t._RESULTS_NG)
def _run_test(self, t):
running = t._running()
if len(running) == 0:
# next test
name = t._pop_test()
LOG.info(LOG_TEST_START, name)
try:
getattr(t, name)()
except Exception:
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value,
exc_traceback, file=sys.stdout)
send_delete_all_flows(t.datapath)
return False
else:
# check
name = 'check_' + running[5:]
if not name in dir(t):
name = '_check_default'
err = 0
try:
# LOG.debug('_run_test: CHECK_TEST = [%s]', name)
getattr(t, name)()
except Exception:
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value,
exc_traceback, file=sys.stdout)
err = 1
finally:
send_delete_all_flows(t.datapath)
if err:
return False
t._check_run()
return True
def _send_delete_all_flows_v10(dp):
rule = nx_match.ClsRule()
match = dp.ofproto_parser.OFPMatch(dp.ofproto.OFPFW_ALL,
0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0)
m = dp.ofproto_parser.OFPFlowMod(
dp, match, 0,
dp.ofproto.OFPFC_DELETE,
0, 0, 0, 0,
dp.ofproto.OFPP_NONE, 0, None)
dp.send_msg(m)
def _send_delete_all_flows_v12(dp):
match = dp.ofproto_parser.OFPMatch()
inst = []
m = dp.ofproto_parser.OFPFlowMod(dp, 0, 0, 0,
dp.ofproto.OFPFC_DELETE,
0, 0, 0, 0,
dp.ofproto.OFPP_ANY, 0xffffffff,
0, match, inst)
dp.send_msg(m)
def send_delete_all_flows(dp):
assert dp.ofproto in (ofproto_v1_0, ofproto_v1_2)
if dp.ofproto == ofproto_v1_0:
_send_delete_all_flows_v10(dp)
elif dp.ofproto == ofproto_v1_2:
_send_delete_all_flows_v12(dp)
else:
# this function will be remove.
dp.send_delete_all_flows()
def run_command(cmd, redirect_output=True, check_exit_code=True, env=None):
if redirect_output:
stdout = subprocess.PIPE
else:
stdout = None
proc = subprocess.Popen(cmd, stdout=stdout,
stderr=subprocess.STDOUT, env=env)
output = proc.communicate()[0]
LOG.debug('Exec command "%s" \n%s', ' '.join(cmd), output)
if check_exit_code and proc.returncode != 0:
raise Exception('Command "%s" failed.\n%s' % (' '.join(cmd), output))
return output
class RunTestBase(object):
""" """
To run the tests is required for the following pair of functions. To run the tests is required for the following pair of functions.
1. test_<test name>() 1. test_<test name>()
To send flows to switch. To send flows to switch.
2. check_<test name>() or _check_default() 2. verify_<test name>() or _verify_default()
To check flows of switch. To check flows of switch.
To deal common values to the functions(test_ and check_)
can use `set_val('name', val)` and `get_val('name')`.
This values is initialized before the next tests.
""" """
def __init__(self): _CONTEXTS = {
super(RunTestBase, self).__init__() 'dpset': dpset.DPSet,
}
self._TEST_STARTED = False def __init__(self, *args, **kwargs):
self._TESTS = [] super(TestFlowBase, self).__init__(*args, **kwargs)
self._RUNNING = '' self.pending = []
self._RESULTS_OK = 0 self.results = {}
self._RESULTS_NG = 0 self.current = None
self._CHECK = {} self.unclear = 0
def _test_started(self): for t in dir(self):
return self._TEST_STARTED if t.startswith("test_"):
self.pending.append(t)
self.unclear = len(self.pending)
def _test_init(self, dp): def delete_all_flows(self, dp):
self.datapath = dp if dp.ofproto == ofproto_v1_0:
self.ofproto = dp.ofproto match = dp.ofproto_parser.OFPMatch(dp.ofproto.OFPFW_ALL,
self.ofproto_parser = dp.ofproto_parser 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0)
m = dp.ofproto_parser.OFPFlowMod(
dp, match, 0,
dp.ofproto.OFPFC_DELETE,
0, 0, 0, 0,
dp.ofproto.OFPP_NONE, 0, None)
elif dp.ofproto == ofproto_v1_2:
match = dp.ofproto_parser.OFPMatch()
m = dp.ofproto_parser.OFPFlowMod(dp, 0, 0, 0,
dp.ofproto.OFPFC_DELETE,
0, 0, 0, 0xffffffff,
dp.ofproto.OFPP_ANY, 0xffffffff,
0, match, [])
for name in dir(self): dp.send_msg(m)
if name.startswith("test_"):
self._TESTS.append(name)
self._TEST_STARTED = True
def _test_completed(self): def send_flow_stats(self, dp):
if self._TEST_STARTED: if dp.ofproto == ofproto_v1_0:
if len(self._RUNNING) + len(self._TESTS) == 0: match = dp.ofproto_parser.OFPMatch(dp.ofproto.OFPFW_ALL,
return True 0, 0, 0, 0, 0,
return False 0, 0, 0, 0, 0, 0, 0)
m = dp.ofproto_parser.OFPFlowStatsRequest(
dp, 0, match,
0, dp.ofproto.OFPP_NONE)
elif dp.ofproto == ofproto_v1_2:
match = dp.ofproto_parser.OFPMatch()
m = dp.ofproto_parser.OFPFlowStatsRequest(dp, 0,
dp.ofproto.OFPP_ANY,
dp.ofproto.OFPG_ANY,
0, 0, match)
def _pop_test(self): dp.send_msg(m)
self._RUNNING = self._TESTS.pop()
return self._RUNNING
def _running(self): def verify_default(self, dp, stats):
return self._RUNNING return 'function %s() is not found.' % ("verify" + self.current[4:], )
def _check_run(self): def start_next_test(self, dp):
self._RUNNING = '' self.delete_all_flows(dp)
dp.send_barrier()
def _check_default(self): if len(self.pending):
err = 'function %s() is not found.' % (self._RUNNING, ) t = self.pending.pop()
self.results(ret=False, msg=err) LOG.info(LOG_TEST_START, t)
self.current = t
def results(self, name=None, ret=True, msg=''): getattr(self, t)(dp)
if not name: dp.send_barrier()
name = self._RUNNING self.send_flow_stats(dp)
if ret:
res = 'OK'
self._RESULTS_OK += 1
else: else:
res = 'NG' LOG.info("TEST_RESULTS:")
self._RESULTS_NG += 1 for t, r in self.results.items():
LOG.info(" %s: %s", t, r)
LOG.info(LOG_TEST_FINISH, self.unclear == 0)
LOG.info('%s %s [%s] %s', LOG_TEST_RESULTS, name, res, '\n' + msg) @handler.set_ev_cls(ofp_event.EventOFPFlowStatsReply,
handler.MAIN_DISPATCHER)
def flow_reply_handler(self, ev):
self.run_verify(ev)
def set_val(self, name, val): @handler.set_ev_cls(ofp_event.EventOFPStatsReply,
self._CHECK[name] = val handler.MAIN_DISPATCHER)
def stats_reply_handler(self, ev):
self.run_verify(ev)
def get_val(self, name): def run_verify(self, ev):
return self._CHECK[name] msg = ev.msg
dp = msg.datapath
def del_val(self, name): verify_func = self.verify_default
del self._CHECK[name] v = "verify" + self.current[4:]
if v in dir(self):
verify_func = getattr(self, v)
def del_val_all(self): result = verify_func(dp, msg.body)
self._CHECK.clear() if result == True:
self.unclear -= 1
def get_ovs_flows(self, target): self.results[self.current] = result
# flows (return): self.start_next_test(dp)
# [flow1, flow2,...]
# flow:
# {'actions': actions, 'rules': rules}
# or {'apply_actions': actions, 'rules': rules}
# or {'write_actions': actions, 'rules': rules}
# or {'clear_actions': actions, 'rules': rules}
# actions, rules:
# {'<name>': <val>}
cmd = ('sudo', 'ovs-ofctl', 'dump-flows', target) @handler.set_ev_cls(dpset.EventDP, dpset.DPSET_EV_DISPATCHER)
output = run_command(cmd) def handler_datapath(self, ev):
if ev.enter:
self.start_next_test(ev.dp)
flows = [] @set_ev_cls(ofp_event.EventOFPBarrierReply, MAIN_DISPATCHER)
for line in output.splitlines(): def barrier_replay_handler(self, ev):
if line.startswith(" "): pass
flow = {}
rules, actions = line.split('actions=')
rules = self.cnv_list(rules, '=')
if actions.startswith("apply_actions"):
a_name = 'apply_actions'
actions = actions[len(a_name) + 1:-1]
elif actions.startswith("write_actions"):
a_name = 'write_actions'
actions = actions[len(a_name) + 1:-1]
elif actions.startswith("clear_actions"):
a_name = 'clear_actions'
actions = actions[len(a_name) + 1:-1]
else:
a_name = 'actions'
actions = self.cnv_list(actions, ':')
flows.append({'rules': rules, a_name: actions, })
return flows
def cnv_list(self, tmp, sep):
list_ = {}
for p in tmp.split(','):
if len(p.strip()) == 0:
continue
if p.find(sep) > 0:
name, val = p.strip().split(sep, 1)
else:
name = val = p.strip()
list_[name] = val
return list_
def cnv_txt(self, tmp, sep='='):
return ",".join([(str(x) + sep + str(tmp[x])) for x in tmp if x >= 0])
def haddr_to_str(self, addr): def haddr_to_str(self, addr):
return mac.haddr_to_str(addr) return mac.haddr_to_str(addr)