refactored verify_stats func
diff --git a/tests/FuncUtils.py b/tests/FuncUtils.py
index 0ef9dc1..388c86c 100644
--- a/tests/FuncUtils.py
+++ b/tests/FuncUtils.py
@@ -19,544 +19,589 @@
#################### Functions for various types of flow_mod ##########################################################################################
-def Exact_Match(self,of_ports,priority=0):
+def exact_match(self,of_ports,priority=0):
# Generate ExactMatch flow .
- #Create a simple tcp packet and generate exact flow match from it.
- Pkt_ExactFlow = simple_tcp_packet()
- match = parse.packet_to_flow_match(Pkt_ExactFlow)
- self.assertTrue(match is not None, "Could not generate flow match from pkt")
- match.in_port = of_ports[0]
- #match.nw_src = 1
- match.wildcards=0
- msg = message.flow_mod()
- msg.out_port = ofp.OFPP_NONE
- msg.command = ofp.OFPFC_ADD
- msg.buffer_id = 0xffffffff
- msg.match = match
- if priority != 0 :
- msg.priority = priority
+ #Create a simple tcp packet and generate exact flow match from it.
+ pkt_exactflow = simple_tcp_packet()
+ match = parse.packet_to_flow_match(pkt_exactflow)
+ self.assertTrue(match is not None, "Could not generate flow match from pkt")
+ match.in_port = of_ports[0]
+ #match.nw_src = 1
+ match.wildcards=0
+ msg = message.flow_mod()
+ msg.out_port = ofp.OFPP_NONE
+ msg.command = ofp.OFPFC_ADD
+ msg.buffer_id = 0xffffffff
+ msg.match = match
+ if priority != 0 :
+ msg.priority = priority
- act = action.action_output()
- act.port = of_ports[1]
- self.assertTrue(msg.actions.add(act), "could not add action")
+ act = action.action_output()
+ act.port = of_ports[1]
+ self.assertTrue(msg.actions.add(act), "could not add action")
- rv = self.controller.message_send(msg)
- self.assertTrue(rv != -1, "Error installing flow mod")
- self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
+ rv = self.controller.message_send(msg)
+ self.assertTrue(rv != -1, "Error installing flow mod")
+ self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
- return (Pkt_ExactFlow,match)
+ return (pkt_exactflow,match)
-def Exact_Match_With_Prio(self,of_ports,priority=0):
- # Generate ExactMatch With Prority flow .
+def exact_match_with_prio(self,of_ports,priority=0):
+ # Generate ExactMatch with action output to port 2
- #Create a simple tcp packet and generate exact flow match from it.
- Pkt_ExactFlow = simple_tcp_packet()
- match = parse.packet_to_flow_match(Pkt_ExactFlow)
- self.assertTrue(match is not None, "Could not generate flow match from pkt")
- match.in_port = of_ports[0]
- #match.nw_src = 1
- match.wildcards=0
- msg = message.flow_mod()
- msg.out_port = ofp.OFPP_NONE
- msg.command = ofp.OFPFC_ADD
- msg.buffer_id = 0xffffffff
- msg.match = match
- if priority != 0 :
- msg.priority = priority
+ #Create a simple tcp packet and generate exact flow match from it.
+ pkt_exactflow = simple_tcp_packet()
+ match = parse.packet_to_flow_match(pkt_exactflow)
+ self.assertTrue(match is not None, "Could not generate flow match from pkt")
+ match.in_port = of_ports[0]
+ #match.nw_src = 1
+ match.wildcards=0
+ msg = message.flow_mod()
+ msg.out_port = ofp.OFPP_NONE
+ msg.command = ofp.OFPFC_ADD
+ msg.buffer_id = 0xffffffff
+ msg.match = match
+ if priority != 0 :
+ msg.priority = priority
- act = action.action_output()
- act.port = of_ports[2]
- self.assertTrue(msg.actions.add(act), "could not add action")
+ act = action.action_output()
+ act.port = of_ports[2]
+ self.assertTrue(msg.actions.add(act), "could not add action")
- rv = self.controller.message_send(msg)
- self.assertTrue(rv != -1, "Error installing flow mod")
- self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
+ rv = self.controller.message_send(msg)
+ self.assertTrue(rv != -1, "Error installing flow mod")
+ self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
- return (Pkt_ExactFlow,match)
+ return (pkt_exactflow,match)
-def Match_All_Except_Source_Address(self,of_ports,priority=0):
+def match_all_except_source_address(self,of_ports,priority=0):
# Generate Match_All_Except_Source_Address flow
- #Create a simple tcp packet and generate match all except src address flow.
- Pkt_WildcardSrc= simple_tcp_packet()
- match1 = parse.packet_to_flow_match(Pkt_WildcardSrc)
- self.assertTrue(match1 is not None, "Could not generate flow match from pkt")
- match1.in_port = of_ports[0]
- #match1.nw_src = 1
- match1.wildcards = ofp.OFPFW_DL_SRC
- msg1 = message.flow_mod()
- msg1.out_port = ofp.OFPP_NONE
- msg1.command = ofp.OFPFC_ADD
- msg1.buffer_id = 0xffffffff
- msg1.match = match1
- if priority != 0 :
- msg1.priority = priority
+ #Create a simple tcp packet and generate match all except src address flow.
+ pkt_wildcardsrc= simple_tcp_packet()
+ match1 = parse.packet_to_flow_match(pkt_wildcardsrc)
+ self.assertTrue(match1 is not None, "Could not generate flow match from pkt")
+ match1.in_port = of_ports[0]
+ #match1.nw_src = 1
+ match1.wildcards = ofp.OFPFW_DL_SRC
+ msg1 = message.flow_mod()
+ msg1.out_port = ofp.OFPP_NONE
+ msg1.command = ofp.OFPFC_ADD
+ msg1.buffer_id = 0xffffffff
+ msg1.match = match1
+ if priority != 0 :
+ msg1.priority = priority
- act1 = action.action_output()
- act1.port = of_ports[1]
- self.assertTrue(msg1.actions.add(act1), "could not add action")
+ act1 = action.action_output()
+ act1.port = of_ports[1]
+ self.assertTrue(msg1.actions.add(act1), "could not add action")
- rv = self.controller.message_send(msg1)
- self.assertTrue(rv != -1, "Error installing flow mod")
- self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
+ rv = self.controller.message_send(msg1)
+ self.assertTrue(rv != -1, "Error installing flow mod")
+ self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
- return (Pkt_WildcardSrc,match1)
+ return (pkt_wildcardsrc,match1)
-def Match_Ethernet_Src_Address(self,of_ports,priority=0):
+def match_wthernet_src_address(self,of_ports,priority=0):
#Generate Match_Ethernet_SrC_Address flow
- #Create a simple tcp packet and generate match on ethernet src address flow
- pkt_MatchSrc = simple_tcp_packet(dl_src='00:01:01:01:01:01')
- match = parse.packet_to_flow_match(pkt_MatchSrc)
- self.assertTrue(match is not None, "Could not generate flow match from pkt")
+ #Create a simple tcp packet and generate match on ethernet src address flow
+ pkt_MatchSrc = simple_tcp_packet(dl_src='00:01:01:01:01:01')
+ match = parse.packet_to_flow_match(pkt_MatchSrc)
+ self.assertTrue(match is not None, "Could not generate flow match from pkt")
- match.wildcards = ofp.OFPFW_ALL ^ofp.OFPFW_DL_SRC
+ match.wildcards = ofp.OFPFW_ALL ^ofp.OFPFW_DL_SRC
- msg = message.flow_mod()
- msg.out_port = ofp.OFPP_NONE
- msg.command = ofp.OFPFC_ADD
- msg.buffer_id = 0xffffffff
- msg.match = match
- if priority != 0 :
- msg.priority = priority
+ msg = message.flow_mod()
+ msg.out_port = ofp.OFPP_NONE
+ msg.command = ofp.OFPFC_ADD
+ msg.buffer_id = 0xffffffff
+ msg.match = match
+ if priority != 0 :
+ msg.priority = priority
- act = action.action_output()
- act.port = of_ports[1]
- self.assertTrue(msg.actions.add(act), "could not add action")
+ act = action.action_output()
+ act.port = of_ports[1]
+ self.assertTrue(msg.actions.add(act), "could not add action")
- rv = self.controller.message_send(msg)
- self.assertTrue(rv != -1, "Error installing flow mod")
- self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
+ rv = self.controller.message_send(msg)
+ self.assertTrue(rv != -1, "Error installing flow mod")
+ self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
- return (pkt_MatchSrc,match)
+ return (pkt_MatchSrc,match)
-def Match_Ethernet_Dst_Address(self,of_ports,priority=0):
+def match_ethernet_dst_address(self,of_ports,priority=0):
#Generate Match_Ethernet_Dst_Address flow
- #Create a simple tcp packet and generate match on ethernet dst address flow
- pkt_MatchDst = simple_tcp_packet(dl_dst='00:01:01:01:01:01')
- match = parse.packet_to_flow_match(pkt_MatchDst)
- self.assertTrue(match is not None, "Could not generate flow match from pkt")
+ #Create a simple tcp packet and generate match on ethernet dst address flow
+ pkt_matchdst = simple_tcp_packet(dl_dst='00:01:01:01:01:01')
+ match = parse.packet_to_flow_match(pkt_matchdst)
+ self.assertTrue(match is not None, "Could not generate flow match from pkt")
- match.wildcards = ofp.OFPFW_ALL ^ofp.OFPFW_DL_DST
- msg = message.flow_mod()
- msg.out_port = ofp.OFPP_NONE
- msg.command = ofp.OFPFC_ADD
- msg.buffer_id = 0xffffffff
- msg.match = match
- if priority != 0 :
- msg.priority = priority
+ match.wildcards = ofp.OFPFW_ALL ^ofp.OFPFW_DL_DST
+ msg = message.flow_mod()
+ msg.out_port = ofp.OFPP_NONE
+ msg.command = ofp.OFPFC_ADD
+ msg.buffer_id = 0xffffffff
+ msg.match = match
+ if priority != 0 :
+ msg.priority = priority
- act = action.action_output()
- act.port = of_ports[1]
- self.assertTrue(msg.actions.add(act), "could not add action")
+ act = action.action_output()
+ act.port = of_ports[1]
+ self.assertTrue(msg.actions.add(act), "could not add action")
- rv = self.controller.message_send(msg)
- self.assertTrue(rv != -1, "Error installing flow mod")
- self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
+ rv = self.controller.message_send(msg)
+ self.assertTrue(rv != -1, "Error installing flow mod")
+ self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
- return (pkt_MatchDst,match)
+ return (pkt_matchdst,match)
-def Wildcard_All(self,of_ports,priority=0):
+def wildcard_all(self,of_ports,priority=0):
# Generate a Wildcard_All Flow
- #Create a simple tcp packet and generate wildcard all flow match from it.
- Pkt_Wildcard = simple_tcp_packet()
- match2 = parse.packet_to_flow_match(Pkt_Wildcard)
- self.assertTrue(match2 is not None, "Could not generate flow match from pkt")
- match2.wildcards=ofp.OFPFW_ALL
- match2.in_port = of_ports[0]
+ #Create a simple tcp packet and generate wildcard all flow match from it.
+ pkt_wildcard = simple_tcp_packet()
+ match2 = parse.packet_to_flow_match(pkt_wildcard)
+ self.assertTrue(match2 is not None, "Could not generate flow match from pkt")
+ match2.wildcards=ofp.OFPFW_ALL
+ match2.in_port = of_ports[0]
- msg2 = message.flow_mod()
- msg2.out_port = ofp.OFPP_NONE
- msg2.command = ofp.OFPFC_ADD
- msg2.buffer_id = 0xffffffff
- msg2.match = match2
- act2 = action.action_output()
- act2.port = of_ports[1]
- self.assertTrue(msg2.actions.add(act2), "could not add action")
- if priority != 0 :
- msg2.priority = priority
+ msg2 = message.flow_mod()
+ msg2.out_port = ofp.OFPP_NONE
+ msg2.command = ofp.OFPFC_ADD
+ msg2.buffer_id = 0xffffffff
+ msg2.match = match2
+ act2 = action.action_output()
+ act2.port = of_ports[1]
+ self.assertTrue(msg2.actions.add(act2), "could not add action")
+ if priority != 0 :
+ msg2.priority = priority
- rv = self.controller.message_send(msg2)
- self.assertTrue(rv != -1, "Error installing flow mod")
- self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
+ rv = self.controller.message_send(msg2)
+ self.assertTrue(rv != -1, "Error installing flow mod")
+ self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
- return (Pkt_Wildcard,match2)
+ return (pkt_wildcard,match2)
-def Wildcard_All_Except_Ingress(self,of_ports,priority=0):
+def wildcard_all_except_ingress(self,of_ports,priority=0):
# Generate Wildcard_All_Except_Ingress_port flow
- #Create a simple tcp packet and generate wildcard all except ingress_port flow.
- Pkt_MatchIngress = simple_tcp_packet()
- match3 = parse.packet_to_flow_match(Pkt_MatchIngress)
- self.assertTrue(match3 is not None, "Could not generate flow match from pkt")
- match3.wildcards = ofp.OFPFW_ALL-ofp.OFPFW_IN_PORT
- match3.in_port = of_ports[0]
+ #Create a simple tcp packet and generate wildcard all except ingress_port flow.
+ pkt_matchingress = simple_tcp_packet()
+ match3 = parse.packet_to_flow_match(pkt_matchingress)
+ self.assertTrue(match3 is not None, "Could not generate flow match from pkt")
+ match3.wildcards = ofp.OFPFW_ALL-ofp.OFPFW_IN_PORT
+ match3.in_port = of_ports[0]
- msg3 = message.flow_mod()
- msg3.command = ofp.OFPFC_ADD
- msg3.match = match3
- msg3.out_port = of_ports[2] # ignored by flow add,flow modify
- msg3.cookie = random.randint(0,9007199254740992)
- msg3.buffer_id = 0xffffffff
- msg3.idle_timeout = 0
- msg3.hard_timeout = 0
- msg3.buffer_id = 0xffffffff
+ msg3 = message.flow_mod()
+ msg3.command = ofp.OFPFC_ADD
+ msg3.match = match3
+ msg3.out_port = of_ports[2] # ignored by flow add,flow modify
+ msg3.cookie = random.randint(0,9007199254740992)
+ msg3.buffer_id = 0xffffffff
+ msg3.idle_timeout = 0
+ msg3.hard_timeout = 0
+ msg3.buffer_id = 0xffffffff
- act3 = action.action_output()
- act3.port = of_ports[1]
- self.assertTrue(msg3.actions.add(act3), "could not add action")
+ act3 = action.action_output()
+ act3.port = of_ports[1]
+ self.assertTrue(msg3.actions.add(act3), "could not add action")
- if priority != 0 :
- msg3.priority = priority
+ if priority != 0 :
+ msg3.priority = priority
- rv = self.controller.message_send(msg3)
- self.assertTrue(rv != -1, "Error installing flow mod")
- self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
+ rv = self.controller.message_send(msg3)
+ self.assertTrue(rv != -1, "Error installing flow mod")
+ self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
- return (Pkt_MatchIngress,match3)
+ return (pkt_matchingress,match3)
-def Wildcard_All_Except_Ingress1(self,of_ports,priority=0):
+def wildcard_all_except_ingress1(self,of_ports,priority=0):
# Generate Wildcard_All_Except_Ingress_port flow with action output to port egress_port 2
- #Create a simple tcp packet and generate wildcard all except ingress_port flow.
- Pkt_MatchIngress = simple_tcp_packet()
- match3 = parse.packet_to_flow_match(Pkt_MatchIngress)
- self.assertTrue(match3 is not None, "Could not generate flow match from pkt")
- match3.wildcards = ofp.OFPFW_ALL-ofp.OFPFW_IN_PORT
- match3.in_port = of_ports[0]
+ #Create a simple tcp packet and generate wildcard all except ingress_port flow.
+ pkt_matchingress = simple_tcp_packet()
+ match3 = parse.packet_to_flow_match(pkt_matchingress)
+ self.assertTrue(match3 is not None, "Could not generate flow match from pkt")
+ match3.wildcards = ofp.OFPFW_ALL-ofp.OFPFW_IN_PORT
+ match3.in_port = of_ports[0]
- msg3 = message.flow_mod()
- msg3.command = ofp.OFPFC_ADD
- msg3.match = match3
- msg3.out_port = of_ports[2] # ignored by flow add,flow modify
- msg3.cookie = random.randint(0,9007199254740992)
- msg3.buffer_id = 0xffffffff
- msg3.idle_timeout = 0
- msg3.hard_timeout = 0
- msg3.buffer_id = 0xffffffff
+ msg3 = message.flow_mod()
+ msg3.command = ofp.OFPFC_ADD
+ msg3.match = match3
+ msg3.out_port = of_ports[2] # ignored by flow add,flow modify
+ msg3.cookie = random.randint(0,9007199254740992)
+ msg3.buffer_id = 0xffffffff
+ msg3.idle_timeout = 0
+ msg3.hard_timeout = 0
+ msg3.buffer_id = 0xffffffff
- act3 = action.action_output()
- act3.port = of_ports[2]
- self.assertTrue(msg3.actions.add(act3), "could not add action")
+ act3 = action.action_output()
+ act3.port = of_ports[2]
+ self.assertTrue(msg3.actions.add(act3), "could not add action")
+ if priority != 0 :
+ msg3.priority = priority
- if priority != 0 :
- msg3.priority = priority
+ rv = self.controller.message_send(msg3)
+ self.assertTrue(rv != -1, "Error installing flow mod")
+ self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
- rv = self.controller.message_send(msg3)
- self.assertTrue(rv != -1, "Error installing flow mod")
- self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
-
- return (Pkt_MatchIngress,match3)
+ return (pkt_matchingress,match3)
-def Match_Vlan_Id(self,of_ports,priority=0):
+def match_vlan_id(self,of_ports,priority=0):
#Generate Match_Vlan_Id
- #Create a simple tcp packet and generate match on ethernet dst address flow
- pkt_MatchVlanId = simple_tcp_packet(dl_vlan_enable=True,dl_vlan=1)
- match = parse.packet_to_flow_match(pkt_MatchVlanId)
- self.assertTrue(match is not None, "Could not generate flow match from pkt")
+ #Create a simple tcp packet and generate match on ethernet dst address flow
+ pkt_matchvlanid = simple_tcp_packet(dl_vlan_enable=True,dl_vlan=1)
+ match = parse.packet_to_flow_match(pkt_matchvlanid)
+ self.assertTrue(match is not None, "Could not generate flow match from pkt")
- match.wildcards = ofp.OFPFW_ALL ^ofp.OFPFW_DL_VLAN
- msg = message.flow_mod()
- msg.out_port = ofp.OFPP_NONE
- msg.command = ofp.OFPFC_ADD
- msg.buffer_id = 0xffffffff
- msg.match = match
- if priority != 0 :
- msg.priority = priority
+ match.wildcards = ofp.OFPFW_ALL ^ofp.OFPFW_DL_VLAN
+ msg = message.flow_mod()
+ msg.out_port = ofp.OFPP_NONE
+ msg.command = ofp.OFPFC_ADD
+ msg.buffer_id = 0xffffffff
+ msg.match = match
+ if priority != 0 :
+ msg.priority = priority
- act = action.action_output()
- act.port = of_ports[1]
- self.assertTrue(msg.actions.add(act), "could not add action")
+ act = action.action_output()
+ act.port = of_ports[1]
+ self.assertTrue(msg.actions.add(act), "could not add action")
- rv = self.controller.message_send(msg)
- self.assertTrue(rv != -1, "Error installing flow mod")
- self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
+ rv = self.controller.message_send(msg)
+ self.assertTrue(rv != -1, "Error installing flow mod")
+ self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
- return (pkt_MatchVlanId,match)
+ return (pkt_matchvlanid,match)
-def Match_Vlan_Pcp(self,of_ports,priority=0):
+def match_vlan_pcp(self,of_ports,priority=0):
#Generate Match_Vlan_Id
- #Create a simple tcp packet and generate match on ethernet dst address flow
- pkt_MatchVlanPcp = simple_tcp_packet(dl_vlan_enable=True,dl_vlan=1,dl_vlan_pcp=10)
- match = parse.packet_to_flow_match(pkt_MatchVlanPcp)
- self.assertTrue(match is not None, "Could not generate flow match from pkt")
+ #Create a simple tcp packet and generate match on ethernet dst address flow
+ pkt_matchvlanpcp = simple_tcp_packet(dl_vlan_enable=True,dl_vlan=1,dl_vlan_pcp=10)
+ match = parse.packet_to_flow_match(pkt_matchvlanpcp)
+ self.assertTrue(match is not None, "Could not generate flow match from pkt")
- match.wildcards = ofp.OFPFW_ALL ^ofp.OFPFW_DL_VLAN_PCP
- msg = message.flow_mod()
- msg.out_port = ofp.OFPP_NONE
- msg.command = ofp.OFPFC_ADD
- msg.buffer_id = 0xffffffff
- msg.match = match
- if priority != 0 :
- msg.priority = priority
+ match.wildcards = ofp.OFPFW_ALL ^ofp.OFPFW_DL_VLAN_PCP
+ msg = message.flow_mod()
+ msg.out_port = ofp.OFPP_NONE
+ msg.command = ofp.OFPFC_ADD
+ msg.buffer_id = 0xffffffff
+ msg.match = match
+ if priority != 0 :
+ msg.priority = priority
- act = action.action_output()
- act.port = of_ports[1]
- self.assertTrue(msg.actions.add(act), "could not add action")
+ act = action.action_output()
+ act.port = of_ports[1]
+ self.assertTrue(msg.actions.add(act), "could not add action")
- rv = self.controller.message_send(msg)
- self.assertTrue(rv != -1, "Error installing flow mod")
- self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
+ rv = self.controller.message_send(msg)
+ self.assertTrue(rv != -1, "Error installing flow mod")
+ self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
- return (pkt_MatchVlanPcp,match)
+ return (pkt_matchvlanpcp,match)
-def Match_Mul_L2(self,of_ports,priority=0):
+def match_mul_l2(self,of_ports,priority=0):
#Generate Match_Mul_L2 flow
- #Create a simple eth packet and generate match on ethernet protocol flow
- pkt_MulL2 = simple_eth_packet(dl_type=0x88cc,dl_src='00:01:01:01:01:01',dl_dst='00:01:01:01:01:02')
- match = parse.packet_to_flow_match(pkt_MulL2)
- self.assertTrue(match is not None, "Could not generate flow match from pkt")
+ #Create a simple eth packet and generate match on ethernet protocol flow
+ pkt_mulL2 = simple_eth_packet(dl_type=0x88cc,dl_src='00:01:01:01:01:01',dl_dst='00:01:01:01:01:02')
+ match = parse.packet_to_flow_match(pkt_mulL2)
+ self.assertTrue(match is not None, "Could not generate flow match from pkt")
- match.wildcards = ofp.OFPFW_ALL ^ofp.OFPFW_DL_TYPE ^ofp.OFPFW_DL_DST ^ofp.OFPFW_DL_SRC
- msg = message.flow_mod()
- msg.out_port = ofp.OFPP_NONE
- msg.command = ofp.OFPFC_ADD
- msg.buffer_id = 0xffffffff
- msg.match = match
- if priority != 0 :
- msg.priority = priority
+ match.wildcards = ofp.OFPFW_ALL ^ofp.OFPFW_DL_TYPE ^ofp.OFPFW_DL_DST ^ofp.OFPFW_DL_SRC
+ msg = message.flow_mod()
+ msg.out_port = ofp.OFPP_NONE
+ msg.command = ofp.OFPFC_ADD
+ msg.buffer_id = 0xffffffff
+ msg.match = match
+ if priority != 0 :
+ msg.priority = priority
- act = action.action_output()
- act.port = of_ports[1]
- self.assertTrue(msg.actions.add(act), "could not add action")
+ act = action.action_output()
+ act.port = of_ports[1]
+ self.assertTrue(msg.actions.add(act), "could not add action")
- rv = self.controller.message_send(msg)
- self.assertTrue(rv != -1, "Error installing flow mod")
- self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
+ rv = self.controller.message_send(msg)
+ self.assertTrue(rv != -1, "Error installing flow mod")
+ self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
- return (pkt_MulL2,match)
+ return (pkt_mulL2,match)
-def Match_Mul_L4(self,of_ports,priority=0):
+def match_mul_L4(self,of_ports,priority=0):
#Generate Match_Mul_L4 flow
#Create a simple tcp packet and generate match on tcp protocol flow
- pkt_MulL4 = simple_tcp_packet(tcp_sport=111,tcp_dport=112)
- match = parse.packet_to_flow_match(pkt_MulL4)
- self.assertTrue(match is not None, "Could not generate flow match from pkt")
+ pkt_mulL4 = simple_tcp_packet(tcp_sport=111,tcp_dport=112)
+ match = parse.packet_to_flow_match(pkt_mulL4)
+ self.assertTrue(match is not None, "Could not generate flow match from pkt")
+ match.wildcards = ofp.OFPFW_ALL ^ofp.OFPFW_TP_SRC ^ofp.OFPFW_TP_DST
+ msg = message.flow_mod()
+ msg.out_port = ofp.OFPP_NONE
+ msg.command = ofp.OFPFC_ADD
+ msg.buffer_id = 0xffffffff
+ msg.match = match
+ if priority != 0 :
+ msg.priority = priority
- match.wildcards = ofp.OFPFW_ALL ^ofp.OFPFW_TP_SRC ^ofp.OFPFW_TP_DST
- msg = message.flow_mod()
- msg.out_port = ofp.OFPP_NONE
- msg.command = ofp.OFPFC_ADD
- msg.buffer_id = 0xffffffff
- msg.match = match
- if priority != 0 :
- msg.priority = priority
+ act = action.action_output()
+ act.port = of_ports[1]
+ self.assertTrue(msg.actions.add(act), "could not add action")
- act = action.action_output()
- act.port = of_ports[1]
- self.assertTrue(msg.actions.add(act), "could not add action")
+ rv = self.controller.message_send(msg)
+ self.assertTrue(rv != -1, "Error installing flow mod")
+ self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
- rv = self.controller.message_send(msg)
- self.assertTrue(rv != -1, "Error installing flow mod")
- self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
+ return (pkt_mulL4,match)
- return (pkt_MulL4,match)
-
-def Match_Ip_Tos(self,of_ports,priority=0):
+def match_ip_tos(self,of_ports,priority=0):
#Generate a Match on IP Type of service flow
#Create a simple tcp packet and generate match on Type of service
- pkt_IpTos = simple_tcp_packet(ip_tos=3)
- match = parse.packet_to_flow_match(pkt_IpTos)
- self.assertTrue(match is not None, "Could not generate flow match from pkt")
+ pkt_iptos = simple_tcp_packet(ip_tos=3)
+ match = parse.packet_to_flow_match(pkt_iptos)
+ self.assertTrue(match is not None, "Could not generate flow match from pkt")
- match.wildcards = ofp.OFPFW_ALL ^ofp.OFPFW_NW_TOS
- msg = message.flow_mod()
- msg.out_port = ofp.OFPP_NONE
- msg.command = ofp.OFPFC_ADD
- msg.buffer_id = 0xffffffff
- msg.match = match
- if priority != 0 :
- msg.priority = priority
+ match.wildcards = ofp.OFPFW_ALL ^ofp.OFPFW_NW_TOS
+ msg = message.flow_mod()
+ msg.out_port = ofp.OFPP_NONE
+ msg.command = ofp.OFPFC_ADD
+ msg.buffer_id = 0xffffffff
+ msg.match = match
+ if priority != 0 :
+ msg.priority = priority
+ act = action.action_output()
+ act.port = of_ports[1]
+ self.assertTrue(msg.actions.add(act), "could not add action")
- act = action.action_output()
- act.port = of_ports[1]
- self.assertTrue(msg.actions.add(act), "could not add action")
+ rv = self.controller.message_send(msg)
+ self.assertTrue(rv != -1, "Error installing flow mod")
+ self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
- rv = self.controller.message_send(msg)
- self.assertTrue(rv != -1, "Error installing flow mod")
- self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
+ return (pkt_iptos,match)
- return (pkt_IpTos,match)
-
-def Match_Tcp_Src(self,of_ports,priority=0):
+def match_tcp_src(self,of_ports,priority=0):
#Generate Match_Tcp_Src
- #Create a simple tcp packet and generate match on tcp source port flow
- pkt_MatchTSrc = simple_tcp_packet(tcp_sport=111)
- match = parse.packet_to_flow_match(pkt_MatchTSrc)
- self.assertTrue(match is not None, "Could not generate flow match from pkt")
+ #Create a simple tcp packet and generate match on tcp source port flow
+ pkt_matchtSrc = simple_tcp_packet(tcp_sport=111)
+ match = parse.packet_to_flow_match(pkt_matchtSrc)
+ self.assertTrue(match is not None, "Could not generate flow match from pkt")
- match.wildcards = ofp.OFPFW_ALL ^ofp.OFPFW_TP_SRC
- msg = message.flow_mod()
- msg.out_port = ofp.OFPP_NONE
- msg.command = ofp.OFPFC_ADD
- msg.buffer_id = 0xffffffff
- msg.match = match
- if priority != 0 :
- msg.priority = priority
+ match.wildcards = ofp.OFPFW_ALL ^ofp.OFPFW_TP_SRC
+ msg = message.flow_mod()
+ msg.out_port = ofp.OFPP_NONE
+ msg.command = ofp.OFPFC_ADD
+ msg.buffer_id = 0xffffffff
+ msg.match = match
+ if priority != 0 :
+ msg.priority = priority
- act = action.action_output()
- act.port = of_ports[1]
- self.assertTrue(msg.actions.add(act), "could not add action")
+ act = action.action_output()
+ act.port = of_ports[1]
+ self.assertTrue(msg.actions.add(act), "could not add action")
- rv = self.controller.message_send(msg)
- self.assertTrue(rv != -1, "Error installing flow mod")
- self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
+ rv = self.controller.message_send(msg)
+ self.assertTrue(rv != -1, "Error installing flow mod")
+ self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
- return (pkt_MatchTSrc,match)
+ return (pkt_matchtSrc,match)
-def Match_Tcp_Dst(self,of_ports,priority=0):
+def match_tcp_dst(self,of_ports,priority=0):
#Generate Match_Tcp_Dst
#Create a simple tcp packet and generate match on tcp destination port flow
- pkt_MatchTDst = simple_tcp_packet(tcp_dport=112)
- match = parse.packet_to_flow_match(pkt_MatchTDst)
- self.assertTrue(match is not None, "Could not generate flow match from pkt")
+ pkt_Matchtdst = simple_tcp_packet(tcp_dport=112)
+ match = parse.packet_to_flow_match(pkt_matchtdst)
+ self.assertTrue(match is not None, "Could not generate flow match from pkt")
- match.wildcards = ofp.OFPFW_ALL ^ofp.OFPFW_TP_DST
- msg = message.flow_mod()
- msg.out_port = ofp.OFPP_NONE
- msg.command = ofp.OFPFC_ADD
- msg.buffer_id = 0xffffffff
- msg.match = match
- if priority != 0 :
- msg.priority = priority
+ match.wildcards = ofp.OFPFW_ALL ^ofp.OFPFW_TP_DST
+ msg = message.flow_mod()
+ msg.out_port = ofp.OFPP_NONE
+ msg.command = ofp.OFPFC_ADD
+ msg.buffer_id = 0xffffffff
+ msg.match = match
+ if priority != 0 :
+ msg.priority = priority
+ act = action.action_output()
+ act.port = of_ports[1]
+ self.assertTrue(msg.actions.add(act), "could not add action")
- act = action.action_output()
- act.port = of_ports[1]
- self.assertTrue(msg.actions.add(act), "could not add action")
+ rv = self.controller.message_send(msg)
+ self.assertTrue(rv != -1, "Error installing flow mod")
+ self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
- rv = self.controller.message_send(msg)
- self.assertTrue(rv != -1, "Error installing flow mod")
- self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
-
- return (pkt_MatchTDst,match)
+ return (pkt_matchtdst,match)
-def Match_Ethernet_Type(self,of_ports,priority=0):
+def match_ethernet_type(self,of_ports,priority=0):
#Generate a Match_Ethernet_Type flow
- #Create a simple tcp packet and generate match on ethernet type flow
- pkt_MatchType = simple_eth_packet(dl_type=0x88cc)
- match = parse.packet_to_flow_match(pkt_MatchType)
- self.assertTrue(match is not None, "Could not generate flow match from pkt")
+ #Create a simple tcp packet and generate match on ethernet type flow
+ pkt_matchtype = simple_eth_packet(dl_type=0x88cc)
+ match = parse.packet_to_flow_match(pkt_matchtype)
+ self.assertTrue(match is not None, "Could not generate flow match from pkt")
- match.wildcards = ofp.OFPFW_ALL ^ofp.OFPFW_DL_TYPE
- msg = message.flow_mod()
- msg.out_port = ofp.OFPP_NONE
- msg.command = ofp.OFPFC_ADD
- msg.buffer_id = 0xffffffff
- msg.match = match
- if priority != 0 :
- msg.priority = priority
+ match.wildcards = ofp.OFPFW_ALL ^ofp.OFPFW_DL_TYPE
+ msg = message.flow_mod()
+ msg.out_port = ofp.OFPP_NONE
+ msg.command = ofp.OFPFC_ADD
+ msg.buffer_id = 0xffffffff
+ msg.match = match
+ if priority != 0 :
+ msg.priority = priority
- act = action.action_output()
- act.port = of_ports[1]
- self.assertTrue(msg.actions.add(act), "could not add action")
+ act = action.action_output()
+ act.port = of_ports[1]
+ self.assertTrue(msg.actions.add(act), "could not add action")
- rv = self.controller.message_send(msg)
- self.assertTrue(rv != -1, "Error installing flow mod")
- self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
+ rv = self.controller.message_send(msg)
+ self.assertTrue(rv != -1, "Error installing flow mod")
+ self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
- return (pkt_MatchType,match)
+ return (pkt_matchtype,match)
-def Strict_Modify_Flow_Action(self,egress_port,match,priority=0):
+def strict_modify_flow_action(self,egress_port,match,priority=0):
# Strict Modify the flow Action
- #Create a flow_mod message , command MODIFY_STRICT
- msg5 = message.flow_mod()
- msg5.match = match
- msg5.cookie = random.randint(0,9007199254740992)
- msg5.command = ofp.OFPFC_MODIFY_STRICT
- msg5.buffer_id = 0xffffffff
- act5 = action.action_output()
- act5.port = egress_port
- self.assertTrue(msg5.actions.add(act5), "could not add action")
+ #Create a flow_mod message , command MODIFY_STRICT
+ msg5 = message.flow_mod()
+ msg5.match = match
+ msg5.cookie = random.randint(0,9007199254740992)
+ msg5.command = ofp.OFPFC_MODIFY_STRICT
+ msg5.buffer_id = 0xffffffff
+ act5 = action.action_output()
+ act5.port = egress_port
+ self.assertTrue(msg5.actions.add(act5), "could not add action")
- if priority != 0 :
- msg5.priority = priority
+ if priority != 0 :
+ msg5.priority = priority
- # Send the flow with action A'
- rv = self.controller.message_send (msg5)
- self.assertTrue(rv != -1, "Error installing flow mod")
- self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
+ # Send the flow with action A'
+ rv = self.controller.message_send (msg5)
+ self.assertTrue(rv != -1, "Error installing flow mod")
+ self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
-def Modify_Flow_Action(self,of_ports,match,priority=0):
+def modify_flow_action(self,of_ports,match,priority=0):
# Modify the flow action
- #Create a flow_mod message , command MODIFY
- msg8 = message.flow_mod()
- msg8.match = match
- msg8.cookie = random.randint(0,9007199254740992)
- msg8.command = ofp.OFPFC_MODIFY
- #Will be ignored for flow adds and flow modify (here for test-case Add_Modify_With_Outport)
- msg8.out_port = of_ports[3]
- msg8.buffer_id = 0xffffffff
- act8 = action.action_output()
- act8.port = of_ports[2]
- self.assertTrue(msg8.actions.add(act8), "could not add action")
+ #Create a flow_mod message , command MODIFY
+ msg8 = message.flow_mod()
+ msg8.match = match
+ msg8.cookie = random.randint(0,9007199254740992)
+ msg8.command = ofp.OFPFC_MODIFY
+ #out_port will be ignored for flow adds and flow modify (here for test-case Add_Modify_With_Outport)
+ msg8.out_port = of_ports[3]
+ msg8.buffer_id = 0xffffffff
+ act8 = action.action_output()
+ act8.port = of_ports[2]
+ self.assertTrue(msg8.actions.add(act8), "could not add action")
- if priority != 0 :
- msg8.priority = priority
+ if priority != 0 :
+ msg8.priority = priority
- # Send the flow with action A'
- rv = self.controller.message_send (msg8)
- self.assertTrue(rv != -1, "Error installing flow mod")
- self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
+ # Send the flow with action A'
+ rv = self.controller.message_send (msg8)
+ self.assertTrue(rv != -1, "Error installing flow mod")
+ self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
-def Enqueue(self,ingress_port,egress_port,egress_queue_id):
+def enqueue(self,ingress_port,egress_port,egress_queue_id):
#Generate a flow with enqueue action i.e output to a queue configured on a egress_port
- pkt = simple_tcp_packet()
- match = packet_to_flow_match(self, pkt)
- match.wildcards &= ~ofp.OFPFW_IN_PORT
- self.assertTrue(match is not None,
- "Could not generate flow match from pkt")
-
- match.in_port = ingress_port
- request = message.flow_mod()
- request.match = match
- request.buffer_id = 0xffffffff
- act = action.action_enqueue()
- act.port = egress_port
- act.queue_id = egress_queue_id
- self.assertTrue(request.actions.add(act), "Could not add action")
-
- logging.info("Inserting flow")
- rv = self.controller.message_send(request)
- self.assertTrue(rv != -1, "Error installing flow mod")
- self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
-
- return (pkt,match)
+ pkt = simple_tcp_packet()
+ match = packet_to_flow_match(self, pkt)
+ match.wildcards &= ~ofp.OFPFW_IN_PORT
+ self.assertTrue(match is not None,
+ "Could not generate flow match from pkt")
+
+ match.in_port = ingress_port
+ request = message.flow_mod()
+ request.match = match
+ request.buffer_id = 0xffffffff
+ act = action.action_enqueue()
+ act.port = egress_port
+ act.queue_id = egress_queue_id
+ self.assertTrue(request.actions.add(act), "Could not add action")
+
+ logging.info("Inserting flow")
+ rv = self.controller.message_send(request)
+ self.assertTrue(rv != -1, "Error installing flow mod")
+ self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
+ return (pkt,match)
########################### Verify Stats Functions ###########################################################################################
+def get_flowstats(self,match):
+ # Generate flow_stats request
+
+ stat_req = message.flow_stats_request()
+ stat_req.match = match
+ stat_req.table_id = 0xff
+ stat_req.out_port = ofp.OFPP_NONE
+
+ logging.info("Sending stats request")
+ response, pkt = self.controller.transact(stat_req,
+ timeout=5)
+ self.assertTrue(response is not None,"No response to stats request")
-def Get_QueueStats(self,port_num,queue_id):
+def get_portstats(self,port_num):
+
+# Return all the port counters in the form a tuple
+ port_stats_req = message.port_stats_request()
+ port_stats_req.port_no = port_num
+ response,pkt = self.controller.transact(port_stats_req)
+ self.assertTrue(response is not None,"No response received for port stats request")
+ rx_pkts=0
+ tx_pkts=0
+ rx_byts=0
+ tx_byts=0
+ rx_drp =0
+ tx_drp = 0
+ rx_err=0
+ tx_err =0
+ rx_fr_err=0
+ rx_ovr_err=0
+ rx_crc_err=0
+ collisions = 0
+ tx_err=0
+
+
+ for obj in response.stats:
+ rx_pkts += obj.rx_packets
+ tx_pkts += obj.tx_packets
+ rx_byts += obj.rx_bytes
+ tx_byts += obj.tx_bytes
+ rx_drp += obj.rx_dropped
+ tx_drp += obj.tx_dropped
+ rx_err += obj.rx_errors
+ rx_fr_err += obj.rx_frame_err
+ rx_ovr_err += obj.rx_over_err
+ rx_crc_err += obj.rx_crc_err
+ collisions+= obj.collisions
+ tx_err += obj.tx_errors
+
+ return (rx_pkts,tx_pkts,rx_byts,tx_byts,rx_drp,tx_drp,rx_err,tx_err,rx_fr_err,rx_ovr_err,rx_crc_err,collisions,tx_err)
+
+def get_queuestats(self,port_num,queue_id):
#Generate Queue Stats request
request = message.queue_stats_request()
@@ -567,169 +612,239 @@
return (queue_stats,p)
-def Verify_TableStats(self,active_entries=0):
-#Verify Table_Stats
+def get_tablestats(self):
+# Send Table_Stats request (retrieve current table counters )
+
+ stat_req = message.table_stats_request()
+ response, pkt = self.controller.transact(stat_req,
+ timeout=5)
+ self.assertTrue(response is not None,
+ "No response to stats request")
+ current_lookedup = 0
+ current_matched = 0
+ current_active = 0
+
+ for obj in response.stats:
+ current_lookedup += obj.lookup_count
+ current_matched += obj.matched_count
+ current_active += obj.active_count
+
+ return (current_lookedup,current_matched,current_active)
+
+
+
+def verify_tablestats(self,expect_lookup=0,expect_match=0,expect_active=0):
+
+ stat_req = message.table_stats_request()
+
+ all_packets_lookedup = 0
+ all_packets_matched = 0
+ all_entries_active = 0
+ lookedup = 0
+ matched = 0
+ active = 0
- #Send Table_Stats_Request
- request = message.table_stats_request()
- response, pkt = self.controller.transact(request, timeout=1)
- self.assertTrue(response is not None, "Did not get response")
- active_count=0
+ for i in range(0,60):
- #Verify active_count in the reply
- for stat in response.stats:
- active_count += stat.active_count
- self.assertTrue(active_entries == active_count,"Incorrect no. of flows in Table")
-
-def Verify_TableStats1(self,current_lookedup,current_matched,expect_lookup,expect_match):
-
- stat_req = message.table_stats_request()
+ logging.info("Sending stats request")
+ # TODO: move REPLY_MORE handling to controller.transact?
response, pkt = self.controller.transact(stat_req,
timeout=5)
- self.assertTrue(response is not None,
- "No response to stats request")
- lookedup = 0
- matched = 0
-
- for obj in response.stats:
- lookedup += obj.lookup_count
- matched += obj.matched_count
-
- lookedup_counter = lookedup-current_lookedup
- matched_counter = matched-current_matched
-
- self.assertTrue(lookedup_counter==expect_lookup, "lookup counter is not incremented properly")
- self.assertTrue(matched_counter==expect_match, "matched counter is not incremented properly")
+ self.assertTrue(response is not None,"No response to stats request")
-def Verify_FlowStats(self,match,byte_count=0,packet_count=0):
+ for item in response.stats:
+ lookedup += item.lookup_count
+ matched += item.matched_count
+ active += item.active_count
+
+ logging.info("Packets Looked up " + str(lookedup) + " packets")
+ if expect_lookup != 0 :
+ if lookedup == expect_lookup:
+ all_packets_lookedup = 1
+
+ logging.info("Packets matched " + str(matched) + "packets")
+ if expect_match != 0 :
+ if matched == expect_match:
+ all_packets_matched = 1
+
+ logging.info("Active flow entries" + str(active) + "flows")
+ if active != 0 :
+ if active == expect_active:
+ all_entries_active = 1
+
+ if all_packets_lookedup == 1 and expect_lookup!= 0 :
+ break
+ if all_packets_matched== 1 and expect_match !=0 :
+ break
+ if all_entries_active ==1 and expect_active != 0 :
+ break
+
+ sleep(1)
+
+ if expect_lookup != 0 :
+ self.assertTrue(all_packets_matched, "lookup counter is not incremented properly")
+ if expect_match != 0 :
+ self.assertTrue(all_packets_matched, "matched counter is not incremented properly")
+ if expect_active != 0 :
+ self.assertTrue(all_entries_active, "active counter is not incremented properly")
+
+
+def verify_flowstats(self,match,byte_count=0,packet_count=0):
# Verify flow counters : byte_count and packet_count
- stat_req = message.flow_stats_request()
- stat_req.match = match
- stat_req.table_id = 0xff
- stat_req.out_port = ofp.OFPP_NONE
+ stat_req = message.flow_stats_request()
+ stat_req.match = match
+ stat_req.table_id = 0xff
+ stat_req.out_port = ofp.OFPP_NONE
+
+ all_packets_rx = 0
+ all_bytes_rx = 0
+ packet_counter = 0
+ byte_counter = 0
+
+ for i in range(0,60):
+ logging.info("Sending stats request")
+ # TODO: move REPLY_MORE handling to controller.transact?
response, pkt = self.controller.transact(stat_req,
- timeout=4)
+ timeout=5)
+ self.assertTrue(response is not None,"No response to stats request")
+
+ for item in response.stats:
+ packet_counter += item.packet_count
+ byte_counter += item.byte_count
+
+ logging.info("Recieved" + str(item.packet_count) + " packets")
+ if packet_count != 0 :
+ if packet_count == packet_counter:
+ all_packets_rx = 1
+
+ logging.info("Received " + str(item.byte_count) + "bytes")
+ if byte_count != 0 :
+ if byte_counter == byte_count:
+ all_bytes_rx = 1
+
+ if all_packets_rx == 1 and packet_count != 0 :
+ break
+ if all_bytes_rx == 1 and byte_count !=0 :
+ break
+ sleep(1)
+
+ if packet_count != 0 :
+ self.assertTrue(all_packets_rx,"packet_count counter is not incremented correctly")
+
+ if byte_count != 0 :
+ self.assertTrue(all_bytes_rx,"byte_count counter is not incremented correctly")
+
+
+def verify_portstats(self, port,tx_packets=0,rx_packets=0,rx_byte=0,tx_byte=0):
+
+
+ stat_req = message.port_stats_request()
+ stat_req.port_no = port
+ all_packets_received = 0
+ all_packets_sent = 0
+ all_bytes_recieved = 0
+ all_bytes_sent = 0
+ sentp = recvp = 0
+ sentb = recvb = 0
+
+ for i in range(0,60):
+ logging.info("Sending stats request")
+ response, pkt = self.controller.transact(stat_req,
+ timeout=5)
self.assertTrue(response is not None,
- "No response to stats request")
- packetcounter=0
- bytecounter=0
- for obj in response.stats:
- packetcounter += obj.packet_count
- bytecounter += obj.byte_count
+ "No response to stats request")
+ self.assertTrue(len(response.stats) == 1,
+ "Did not receive port stats reply")
+ for item in response.stats:
+ sentp += item.tx_packets
+ recvp += item.rx_packets
+ sentb += item.tx_bytes
+ recvb += item.rx_bytes
+
+ logging.info("Sent " + str(sentp) + " packets")
+ if tx_packets != 0:
+ if item.tx_packets == tx_packets:
+ all_packets_sent = 1
+
+ logging.info("Received " + str(recvp) + " packets")
+ if rx_packets !=0 :
+ if item.rx_packets == rx_packets:
+ all_packets_received = 1
- self.assertTrue(packetcounter==packet_count, "packet counter is not incremented properly")
- self.assertTrue(bytecounter==byte_count, "byte counter is not incremented properly")
+ logging.info("Received " + str(recvb) + "bytes")
+ if rx_byte !=0 :
+ if item.rx_bytes == rx_byte:
+ all_bytes_received = 1
+
+ logging.info("Sent" + str(sentb) + "bytes")
+ if tx_byte !=0 :
+ if item.tx_bytes == tx_byte:
+ all_bytes_sent = 1
+
+ if rx_packets !=0 and all_packets_received == 1:
+ break
+ if tx_packets !=0 and all_packets_sent == 1:
+ break
+ if rx_byte !=0 and all_bytes_received == 1:
+ break
+ if tx_byte !=0 and all_bytes_sent == 1:
+ break
+
+ sleep(1)
+
+ if (rx_packets !=0):
+ self.assertTrue(all_packets_received == 1 ,"rx_packets counter is not incremented correctly")
+ if (tx_packets !=0):
+ self.assertTrue(all_packets_sent == 1,"tx_packets counter is not incremented correctly")
+ if (rx_byte !=0):
+ self.assertTrue(all_bytes_received == 1 ,"rx_bytes counter is not incremented correctly")
+ if (tx_byte !=0):
+ self.assertTrue(all_bytes_sent == 1,"tx_bytes counter is not incremented correctly")
-def Verify_PortStats(self,in_port,rx_dropped):
-#Verify Port counters like rx_dropped
-
- port_stats_req = message.port_stats_request()
- port_stats_req.port_no = in_port
- resp,pkt = self.controller.transact(port_stats_req)
- self.assertTrue(resp is not None,"No response received for port stats request")
- self.assertTrue(resp.rx_dropped == rx_dropped, "Packets not dropped")
-
-def Verify_PortStats1(self,out_port,current_counter,rx_packets):
-#Verify Port counters like rx_packets
-
- port_stats_req = message.port_stats_request()
- port_stats_req.port_no = out_port
- response,pkt = self.controller.transact(port_stats_req)
- self.assertTrue(response is not None,"No response received for port stats request")
- rxpackets=0
-
- for obj in response.stats:
- rxpackets += obj.rx_packets
- rx_packet_counter = rxpackets-current_counter
- self.assertEqual(rx_packets,rx_packet_counter,"recieved packet counter is not incremented properly")
-
-def Verify_PortStats2(self,out_port,current_counter,tx_packets):
-#Verify Port counters like tx_packets
-
- port_stats_req = message.port_stats_request()
- port_stats_req.port_no = out_port
- response,pkt = self.controller.transact(port_stats_req)
- self.assertTrue(response is not None,"No response received for port stats request")
- txpackets=0
-
- for obj in response.stats:
- txpackets += obj.tx_packets
- tx_packet_counter = txpackets-current_counter
- self.assertEqual(tx_packets,tx_packet_counter,"Transmitted packet counter is not incremented properly")
-
-
-def Verify_PortStats3(self,out_port,current_counter,rx_bytes):
-#Verify Port counters like rx_bytes
-
- port_stats_req = message.port_stats_request()
- port_stats_req.port_no = out_port
- response,pkt = self.controller.transact(port_stats_req)
- self.assertTrue(response is not None,"No response received for port stats request")
- rxbytes=0
-
- for obj in response.stats:
- rxbytes += obj.rx_bytes
- rx_byte_counter = rxbytes-current_counter
- self.assertEqual(rx_bytes,rx_byte_counter,"Recieved byte counter is not incremented properly")
-
-def Verify_PortStats4(self,out_port,current_counter,tx_bytes):
-#Verify Port counters like tx_bytes
-
- port_stats_req = message.port_stats_request()
- port_stats_req.port_no = out_port
- response,pkt = self.controller.transact(port_stats_req)
- self.assertTrue(response is not None,"No response received for port stats request")
- txbytes=0
-
- for obj in response.stats:
- txbytes += obj.tx_bytes
- tx_byte_counter = txbytes-current_counter
- self.assertEqual(tx_bytes,tx_byte_counter,"Transmitted byte counter is not incremented properly")
############################## Various delete commands #############################################################################################
-def Strict_Delete(self,match,priority=0):
+def strict_delete(self,match,priority=0):
# Issue Strict Delete
- #Create flow_mod message, command DELETE_STRICT
- msg4 = message.flow_mod()
- msg4.out_port = ofp.OFPP_NONE
- msg4.command = ofp.OFPFC_DELETE_STRICT
- msg4.buffer_id = 0xffffffff
- msg4.match = match
+ #Create flow_mod message, command DELETE_STRICT
+ msg4 = message.flow_mod()
+ msg4.out_port = ofp.OFPP_NONE
+ msg4.command = ofp.OFPFC_DELETE_STRICT
+ msg4.buffer_id = 0xffffffff
+ msg4.match = match
- if priority != 0 :
- msg4.priority = priority
-
- rv = self.controller.message_send(msg4)
- self.assertTrue(rv!= -1, "Error installing flow mod")
- self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
+ if priority != 0 :
+ msg4.priority = priority
+ rv = self.controller.message_send(msg4)
+ self.assertTrue(rv!= -1, "Error installing flow mod")
+ self.assertEqual(do_barrier(self.controller), 0, "Barrier failed")
-def NonStrict_Delete(self,match,priority=0):
+def nonstrict_delete(self,match,priority=0):
# Issue Non_Strict Delete
- #Create flow_mod message, command DELETE
- msg6 = message.flow_mod()
- msg6.out_port = ofp.OFPP_NONE
- msg6.command = ofp.OFPFC_DELETE
- msg6.buffer_id = 0xffffffff
- msg6.match = match
+ #Create flow_mod message, command DELETE
+ msg6 = message.flow_mod()
+ msg6.out_port = ofp.OFPP_NONE
+ msg6.command = ofp.OFPFC_DELETE
+ msg6.buffer_id = 0xffffffff
+ msg6.match = match
- if priority != 0 :
- msg6.priority = priority
+ if priority != 0 :
+ msg6.priority = priority
- rv = self.controller.message_send(msg6)
- self.assertTrue(rv != -1, "Error installing flow mod")
- self.assertEqual(do_barrier(self.controller),0, "Barrier failed")
+ rv = self.controller.message_send(msg6)
+ self.assertTrue(rv != -1, "Error installing flow mod")
+ self.assertEqual(do_barrier(self.controller),0, "Barrier failed")
###########################################################################################################################################################
-def SendPacket(obj, pkt, ingress_port, egress_port):
+def send_packet(obj, pkt, ingress_port, egress_port):
#Send Packets on a specified ingress_port and verify if its recieved on correct egress_port.
obj.dataplane.send(ingress_port, str(pkt))