def runTest(self): table_id = testutils.EX_L2_TABLE of_ports = exact_port_map.keys() egr_port1 = of_ports[len(of_ports)-1] egr_port2 = of_ports[0] pkt = testutils.simple_tcp_packet(dl_src='99:33:11:11:11:55', dl_dst='33:33:11:11:77:66') pkt_metadata = {'metadata_val':0x99999999, 'metadata_msk':0xFFFFFFFFFFFFFFFF} request = testutils.flow_msg_create(self, pkt, pkt_metadata, egr_port = egr_port1, table_id = table_id) testutils.flow_msg_install(self, request) #"mod it ,add outport 1" request_mod = testutils.flow_msg_create(self, pkt, match_fields = request.match_fields, egr_port = egr_port2, table_id = table_id) request_mod.command = ofp.OFPFC_MODIFY testutils.ofmsg_send(self, request_mod) #print(flow_mod.show()) #"read it back;" stat_req = message.flow_stats_request() stat_req.buffer_id = 0xffffffff stat_req.table_id = table_id stat_req.out_port = ofp.OFPP_ANY stat_req.out_group = ofp.OFPG_ANY stat_req.match_fields = request.match_fields response, _ = self.controller.transact(stat_req, timeout=2) #print(response.show()) self.assertTrue(isinstance(response,message.flow_stats_reply),"Not a flow_stats_reply") self.assertEqual(len(response.stats),1, "len of stats is:"+str(len(response.stats))) self.assertEqual(response.stats[0].instructions.items[0].actions.items[0].port, request_mod.instructions.items[0].actions.items[0].port, "action error:"+str(response.stats[0].instructions.items[0].actions.items[0].port))
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 test_timeout = 10 all_packets_received = 0 for i in range(0,test_timeout): response, pkt = self.controller.transact(stat_req, timeout=test_timeout) self.assertTrue(response is not None, "No response to stats request") for obj in response.stats: if ( obj.packet_count == packet_count and obj.byte_count == byte_count ) : all_packets_received = 1 if all_packets_received: break sleep(1) self.assertTrue(all_packets_received, "Flow counters are incorrect")
def runTest(self): table_id = testutils.EX_ACL_TABLE port_in = exact_port_map.keys()[0] egr_port = exact_port_map.keys()[1] #"clear swtich;" testutils.delete_all_flows(self.controller, self.logger) # make packet pkt = testutils.simple_tcp_packet(ip_src='192.168.0.99') match_ls = testutils.packet_to_exact_flow_match(pkt = pkt, table_id = table_id, ing_port = port_in) exact_table_output(self, table_id, match_ls, egr_port = egr_port) testutils.do_barrier(self.controller) "get flow stats" stat_req = message.flow_stats_request() stat_req.buffer_id = 0xffffffff stat_req.table_id = table_id stat_req.match_fields = match_ls response, _ = self.controller.transact(stat_req, timeout=2) "send a packet from port_in " self.dataplane.send(port_in, str(pkt)) "poll from the egr_port port" (port_rec, pkt_rec, _) = self.dataplane.poll(port_number=egr_port, timeout=1) self.assertTrue(pkt_rec is not None,"rec none packet") self.assertEqual(str(pkt), str(pkt_rec), 'retruned pkt not equal to the original pkt')
def verifyStats(self, match, out_port, test_timeout, packet_count): stat_req = message.flow_stats_request() stat_req.match = match stat_req.table_id = 0xff stat_req.out_port = out_port all_packets_received = 0 for i in range(0, test_timeout): fs_logger.info("Sending stats request") response, pkt = self.controller.transact(stat_req, timeout=test_timeout) self.assertTrue(response is not None, "No response to stats request") self.assertTrue( len(response.stats) == 1, "Did not receive flow stats reply") for obj in response.stats: # TODO: pad1 and pad2 fields may be nonzero, is this a bug? # for now, just clear them so the assert is simpler #obj.match.pad1 = 0 #obj.match.pad2 = [0, 0] #self.assertEqual(match, obj.match, # "Matches do not match") fs_logger.info("Received " + str(obj.packet_count) + " packets") if obj.packet_count == packet_count: all_packets_received = 1 if all_packets_received: break sleep(1) self.assertTrue(all_packets_received, "Packet count does not match number sent")
def runTest(self): table_id = testutils.EX_L2_TABLE of_ports = exact_port_map.keys() egr_port = of_ports[0] pkt = testutils.simple_tcp_packet(dl_src='22:22:22:22:22:22', dl_dst='22:22:22:22:22:22') pkt_metadata = {'metadata_val':0x1122334455667788, 'metadata_msk':0xFFFFFFFFFFFFFFFF} request = testutils.flow_msg_create(self, pkt, pkt_metadata, egr_port = egr_port, table_id = table_id) testutils.flow_msg_install(self, request) #"delete it" request_del = testutils.flow_msg_create(self, pkt, match_fields = request.match_fields, egr_port = egr_port, table_id = table_id) request_del.command = ofp.OFPFC_DELETE testutils.ofmsg_send(self, request_del) #'read it back , returns blank;' stat_req = message.flow_stats_request() stat_req.buffer_id = 0xffffffff stat_req.table_id = table_id stat_req.out_port = ofp.OFPP_ANY stat_req.out_group = ofp.OFPG_ANY stat_req.match_fields = request.match_fields response, _ = self.controller.transact(stat_req, timeout=2) self.assertTrue(isinstance(response,message.flow_stats_reply),"Not a flow_stats_reply") self.assertEqual(len(response.stats),0, "len of stats is:"+str(len(response.stats)))
def runTest(self): #"clear swtich;" testutils.delete_all_flows(self.controller, self.logger) table_id = testutils.EX_ACL_TABLE of_ports = exact_port_map.keys() port_in = of_ports[0] egr_port = of_ports[1] vlan_tags=[{'type': 0x8100, 'vid': 3, 'pcp': 1}] mpls_tags=[{'type': 0x8847, 'label': 22, 'tc': 2, 'ttl': 48}] pkt = testutils.simple_tcp_packet(ip_src='192.168.0.99', dl_dst='00:06:07:08:09:aa', \ vlan_tags = [], mpls_tags = []) match_ls = testutils.packet_to_exact_flow_match(pkt, None, testutils.EX_L2_TABLE, port_in) exact_table_output(self, table_id, match_ls, egr_port = egr_port) stat_req = message.flow_stats_request() stat_req.buffer_id = 0xffffffff stat_req.table_id = table_id stat_req.match_fields = match_ls stat_req.out_port = ofp.OFPP_ANY stat_req.out_group = ofp.OFPP_ANY response, _ = self.controller.transact(stat_req, timeout=2) #print(response.show()) self.assertTrue(isinstance(response,message.flow_stats_reply),"Not a flow_stats_reply") self.assertEqual(len(response.stats),1, "len of stats is:"+str(len(response.stats)))
def verifyStats(self, match, out_port, test_timeout, packet_count): stat_req = message.flow_stats_request() stat_req.match = match stat_req.table_id = 0xff stat_req.out_port = out_port all_packets_received = 0 for i in range(0,test_timeout): fs_logger.info("Sending stats request") # TODO: move REPLY_MORE handling to controller.transact? response, pkt = self.controller.transact(stat_req, timeout=test_timeout) self.assertTrue(response is not None, "No response to stats request") total_packets = self.sumStatsReplyCounts(response) while response.flags == ofp.OFPSF_REPLY_MORE: response, pkt = self.controller.poll(exp_msg= ofp.OFPT_STATS_REPLY, timeout=test_timeout) total_packets += self.sumStatsReplyCounts(response) if total_packets == packet_count: all_packets_received = 1 break sleep(1) self.assertTrue(all_packets_received, "Total stats packet count " + str(total_packets) + " does not match number sent " + str(packet_count))
def runTest(self): table_id = testutils.EX_ACL_TABLE port_in = exact_port_map.keys()[0] egr_port = exact_port_map.keys()[1] #"clear swtich;" testutils.delete_all_flows(self.controller, self.logger) # make packet pkt = testutils.simple_tcp_packet(ip_src='192.168.0.99') match_ls = testutils.packet_to_exact_flow_match(pkt=pkt, table_id=table_id, ing_port=port_in) exact_table_output(self, table_id, match_ls, egr_port=egr_port) testutils.do_barrier(self.controller) "get flow stats" stat_req = message.flow_stats_request() stat_req.buffer_id = 0xffffffff stat_req.table_id = table_id stat_req.match_fields = match_ls response, _ = self.controller.transact(stat_req, timeout=2) "send a packet from port_in " self.dataplane.send(port_in, str(pkt)) "poll from the egr_port port" (port_rec, pkt_rec, _) = self.dataplane.poll(port_number=egr_port, timeout=1) self.assertTrue(pkt_rec is not None, "rec none packet") self.assertEqual(str(pkt), str(pkt_rec), 'retruned pkt not equal to the original pkt')
def verifyStats(self, match, out_port, test_timeout, packet_count): stat_req = message.flow_stats_request() stat_req.match = match stat_req.table_id = 0xff stat_req.out_port = out_port all_packets_received = 0 for i in range(0, test_timeout): fs_logger.info("Sending stats request") # TODO: move REPLY_MORE handling to controller.transact? response, pkt = self.controller.transact(stat_req, timeout=test_timeout) self.assertTrue(response is not None, "No response to stats request") total_packets = self.sumStatsReplyCounts(response) while response.flags == ofp.OFPSF_REPLY_MORE: response, pkt = self.controller.poll( exp_msg=ofp.OFPT_STATS_REPLY, timeout=test_timeout) total_packets += self.sumStatsReplyCounts(response) if total_packets == packet_count: all_packets_received = 1 break sleep(1) self.assertTrue( all_packets_received, "Total stats packet count " + str(total_packets) + " does not match number sent " + str(packet_count))
def runTest(self): table_id = testutils.EX_L2_TABLE of_ports = exact_port_map.keys() egr_port = of_ports[len(of_ports) - 1] pkt = testutils.simple_tcp_packet(dl_src='00:22:44:62:9b:1c', dl_dst='00:13:07:5f:61:ab') pkt_metadata = { 'metadata_val': 0xaa22334455667788, 'metadata_msk': 0xFFFFFFFFFFFFFFFF } request = testutils.flow_msg_create(self, pkt, pkt_metadata, egr_port=egr_port, table_id=table_id) request.hard_timeout = 8 request.idle_timeout = 8 testutils.flow_msg_install(self, request) #"get flow stats" stat_req = message.flow_stats_request() stat_req.buffer_id = 0xffffffff stat_req.table_id = table_id stat_req.out_port = ofp.OFPP_ANY stat_req.out_group = ofp.OFPG_ANY stat_req.match_fields = request.match_fields response, _ = self.controller.transact(stat_req, timeout=2) self.assertTrue(isinstance(response, message.flow_stats_reply), "Not a flow_stats_reply") self.assertEqual(len(response.stats), 1, "len of stats is:" + str(len(response.stats)))
def runTest(self): logging.info("Running DurationPerFlow test") of_ports = config["port_map"].keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") #Clear switch state delete_all_flows(self.controller) logging.info("Insert any flow") logging.info("Send Flow_stats request after n sec intervals") logging.info("Verify duration_sec and nsec counters are incrementing in accordance with the life of flow") #Create a flow with match on ingress_port (pkt,match) = wildcard_all_except_ingress(self,of_ports) #Create 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 expected_duration = 3 sleep(expected_duration) response, pkt = self.controller.transact(stat_req) self.assertTrue(response is not None,"No response to stats request") self.assertTrue(len(response.stats) == 1,"Did not receive flow stats reply") stat = response.stats[0] logging.info("Duration of flow is %d s %d ns", stat.duration_sec, stat.duration_nsec) self.assertTrue(stat.duration_sec == expected_duration, "Flow stats reply incorrect")
def verifyStats(self, match, out_port, test_timeout, packet_count): stat_req = message.flow_stats_request() stat_req.match = match stat_req.table_id = 0xff stat_req.out_port = out_port all_packets_received = 0 for i in range(0,test_timeout): fs_logger.info("Sending stats request") response, pkt = self.controller.transact(stat_req, timeout=test_timeout) self.assertTrue(response is not None, "No response to stats request") self.assertTrue(len(response.stats) == 1, "Did not receive flow stats reply") for obj in response.stats: # TODO: pad1 and pad2 fields may be nonzero, is this a bug? # for now, just clear them so the assert is simpler #obj.match.pad1 = 0 #obj.match.pad2 = [0, 0] #self.assertEqual(match, obj.match, # "Matches do not match") fs_logger.info("Received " + str(obj.packet_count) + " packets") if obj.packet_count == packet_count: all_packets_received = 1 if all_packets_received: break sleep(1) self.assertTrue(all_packets_received, "Packet count does not match number sent")
def runTest(self): #"clear swtich;" testutils.delete_all_flows(self.controller, self.logger) table_id = testutils.EX_ACL_TABLE of_ports = exact_port_map.keys() port_in = of_ports[0] egr_port = of_ports[1] vlan_tags = [{'type': 0x8100, 'vid': 3, 'pcp': 1}] mpls_tags = [{'type': 0x8847, 'label': 22, 'tc': 2, 'ttl': 48}] pkt = testutils.simple_tcp_packet(ip_src='192.168.0.99', dl_dst='00:06:07:08:09:aa', \ vlan_tags = [], mpls_tags = []) match_ls = testutils.packet_to_exact_flow_match( pkt, None, testutils.EX_L2_TABLE, port_in) exact_table_output(self, table_id, match_ls, egr_port=egr_port) stat_req = message.flow_stats_request() stat_req.buffer_id = 0xffffffff stat_req.table_id = table_id stat_req.match_fields = match_ls stat_req.out_port = ofp.OFPP_ANY stat_req.out_group = ofp.OFPP_ANY response, _ = self.controller.transact(stat_req, timeout=2) #print(response.show()) self.assertTrue(isinstance(response, message.flow_stats_reply), "Not a flow_stats_reply") self.assertEqual(len(response.stats), 1, "len of stats is:" + str(len(response.stats)))
def runTest(self): basic_logger.info("Running StatsGet") basic_logger.info("Inserting trial flow") request = message.flow_mod() request.match.wildcards = ofp.OFPFW_ALL request.buffer_id = 0xffffffff for i in range(1, 5): request.priority = i * 1000 basic_logger.debug("Adding flow %d" % i) rv = self.controller.message_send(request) self.assertTrue(rv != -1, "Failed to insert test flow %d" % i) basic_logger.info("Removing all flows") testutils.delete_all_flows(self.controller, basic_logger) basic_logger.info("Sending flow request") request = message.flow_stats_request() request.out_port = ofp.OFPP_ANY request.out_group = ofp.OFPG_ANY request.table_id = 0xff request.match.wildcards = 0 # ofp.OFPFW_ALL response, _ = self.controller.transact(request, timeout=2) self.assertTrue(response is not None, "Did not get response") self.assertTrue(isinstance(response, message.flow_stats_reply), "Not a flow_stats_reply") self.assertEqual(len(response.stats), 0) basic_logger.debug(response.show())
def runTest(self): request = message.flow_stats_request() request.out_port = ofp.OFPP_ANY request.out_group = ofp.OFPG_ANY request.table_id = ofp.OFPTT_ALL response, _ = self.controller.transact(request, timeout=2) #print(response.show()) self.logger.info(response.show())
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_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 runTest(self): delete_all_flows(self.controller) match = ofp.ofp_match() match.wildcards = 0 stat_req = message.flow_stats_request() stat_req.match = match stat_req.table_id = 0xff stat_req.out_port = ofp.OFPP_NONE response, pkt = self.controller.transact(stat_req) self.assertTrue(response is not None, "No response to stats request") self.assertEquals(len(response.stats), 0) self.assertEquals(response.flags, 0)
def runTest(self): global pa_port_map of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") ingress_port = of_ports[0] egress_port = of_ports[1] rc = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rc, 0, "Failed to delete all flows") #controller send flow_mod to switch pkt = testutils.simple_tcp_packet() flow_mod_add = testutils.flow_msg_create( self, pkt, ing_port=ingress_port, egr_port=egress_port, table_id=testutils.EX_ACL_TABLE) testutils.flow_msg_install(self, flow_mod_add) #user send pkt to switch, switch transfer to eng_port pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) (rcv_port, rcv_pkt, _) = self.dataplane.poll(egress_port, timeout=2) self.assertTrue(rcv_pkt is not None, "Did not receive packet") pa_logger.debug("Packet len " + str(len(pkt)) + " in on " + str(rcv_port)) self.assertEqual(rcv_port, egress_port, "Unexpected receive port") self.assertEqual(str(pkt), str(rcv_pkt), 'Response packet does not match send packet') #check the stats msg stat_req = message.flow_stats_request() stat_req.match_fields = flow_mod_add.match_fields stat_req.table_id = 0xff stat_req.out_port = ofp.OFPP_ANY stat_req.out_group = ofp.OFPG_ANY pa_logger.info("Sending stats request") testutils.ofmsg_send(self, stat_req) (response, _) = self.controller.poll(ofp.OFPT_MULTIPART_REPLY, 2) self.assertTrue(response, "No Flow_stats reply") #print "YYY: Stats reply is \n%s" % (response.show()) self.assertEqual(len(response.stats), 1, "Did not receive flow stats reply") self.assertEqual(response.stats[0].packet_count, 1) self.assertEqual(response.stats[0].byte_count, len(rcv_pkt))
def runTest(self): logging = get_logger() logging.info("Running Grp100No20 BadRequestBadVersion Test") # Send a flow_stats request , with incorrect version logging.info("Sending flow_mod request.. ") request = message.flow_stats_request() request.header.version = 0 rv = self.controller.message_send(request) logging.info("Waiting for OFPT_ERROR message..") (response, pkt) = self.controller.poll(exp_msg=ofp.OFPT_ERROR, timeout=5) self.assertTrue(response is not None, "Switch did not reply with error message") self.assertTrue(response.type == ofp.OFPET_BAD_REQUEST, "Error type is not OFPET_BAD_REQUEST") self.assertTrue(response.code == ofp.OFPBRC_BAD_VERSION, "Error code is not OFPBRC_BAD_VERSION")
def runTest(self): rc = delete_all_flows(self.controller) self.assertEqual(rc, 0, "Failed to delete all flows") match = ofp.ofp_match() match.wildcards = 0 stat_req = message.flow_stats_request() stat_req.match = match stat_req.table_id = 0xff stat_req.out_port = ofp.OFPP_NONE response, pkt = self.controller.transact(stat_req) self.assertTrue(response is not None, "No response to stats request") self.assertEquals(len(response.stats), 0) self.assertEquals(response.flags, 0)
def runTest(self): basic_logger.info("Running StatsGet") basic_logger.info("Inserting trial flow") request = flow_mod_gen(basic_port_map, True) rv = self.controller.message_send(request) self.assertTrue(rv != -1, "Failed to insert test flow") basic_logger.info("Sending flow request") request = message.flow_stats_request() request.out_port = ofp.OFPP_NONE request.table_id = 0xff request.match.wildcards = 0 # ofp.OFPFW_ALL response, pkt = self.controller.transact(request) self.assertTrue(response is not None, "Did not get response") basic_logger.debug(response.show())
def runTest(self): table_id = testutils.EX_L2_TABLE of_ports = exact_port_map.keys() egr_port1 = of_ports[len(of_ports) - 1] egr_port2 = of_ports[0] pkt = testutils.simple_tcp_packet(dl_src='99:33:11:11:11:55', dl_dst='33:33:11:11:77:66') pkt_metadata = { 'metadata_val': 0x99999999, 'metadata_msk': 0xFFFFFFFFFFFFFFFF } request = testutils.flow_msg_create(self, pkt, pkt_metadata, egr_port=egr_port1, table_id=table_id) testutils.flow_msg_install(self, request) #"mod it ,add outport 1" request_mod = testutils.flow_msg_create( self, pkt, match_fields=request.match_fields, egr_port=egr_port2, table_id=table_id) request_mod.command = ofp.OFPFC_MODIFY testutils.ofmsg_send(self, request_mod) #print(flow_mod.show()) #"read it back;" stat_req = message.flow_stats_request() stat_req.buffer_id = 0xffffffff stat_req.table_id = table_id stat_req.out_port = ofp.OFPP_ANY stat_req.out_group = ofp.OFPG_ANY stat_req.match_fields = request.match_fields response, _ = self.controller.transact(stat_req, timeout=2) #print(response.show()) self.assertTrue(isinstance(response, message.flow_stats_reply), "Not a flow_stats_reply") self.assertEqual(len(response.stats), 1, "len of stats is:" + str(len(response.stats))) self.assertEqual( response.stats[0].instructions.items[0].actions.items[0].port, request_mod.instructions.items[0].actions.items[0].port, "action error:" + str(response.stats[0].instructions.items[0].actions.items[0].port))
def runTest(self): logging.info("Running StatsGet") logging.info("Inserting trial flow") request = flow_mod_gen(config["port_map"], True) rv = self.controller.message_send(request) self.assertTrue(rv != -1, "Failed to insert test flow") logging.info("Sending flow request") request = message.flow_stats_request() request.out_port = ofp.OFPP_NONE request.table_id = 0xff request.match.wildcards = 0 # ofp.OFPFW_ALL response, pkt = self.controller.transact(request) self.assertTrue(response is not None, "Did not get response for flow stats") logging.debug(response.show())
def runTest(self): global pa_port_map of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") ingress_port = of_ports[0]; egress_port = of_ports[1]; rc = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rc, 0, "Failed to delete all flows") #controller send flow_mod to switch pkt = testutils.simple_tcp_packet() flow_mod_add = testutils.flow_msg_create(self, pkt, ing_port=ingress_port, egr_port=egress_port, table_id=testutils.EX_ACL_TABLE) testutils.flow_msg_install(self, flow_mod_add) #user send pkt to switch, switch transfer to eng_port pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) (rcv_port, rcv_pkt, _) = self.dataplane.poll(egress_port, timeout=2) self.assertTrue(rcv_pkt is not None, "Did not receive packet") pa_logger.debug("Packet len " + str(len(pkt)) + " in on " + str(rcv_port)) self.assertEqual(rcv_port, egress_port, "Unexpected receive port") self.assertEqual(str(pkt), str(rcv_pkt), 'Response packet does not match send packet') #check the stats msg stat_req = message.flow_stats_request() stat_req.match_fields = flow_mod_add.match_fields stat_req.table_id = 0xff stat_req.out_port = ofp.OFPP_ANY; stat_req.out_group = ofp.OFPG_ANY; pa_logger.info("Sending stats request") testutils.ofmsg_send(self, stat_req) (response, _) = self.controller.poll(ofp.OFPT_MULTIPART_REPLY, 2) self.assertTrue(response, "No Flow_stats reply") #print "YYY: Stats reply is \n%s" % (response.show()) self.assertEqual(len(response.stats), 1, "Did not receive flow stats reply") self.assertEqual(response.stats[0].packet_count,1) self.assertEqual(response.stats[0].byte_count,len(rcv_pkt))
def runTest(self): logging = get_logger() logging.info("Running Grp100No20 BadRequestBadVersion Test") #Send a flow_stats request , with incorrect version logging.info("Sending flow_mod request.. ") request=message.flow_stats_request(); request.header.version=0 rv = self.controller.message_send(request) logging.info("Waiting for OFPT_ERROR message..") (response, pkt) = self.controller.poll(exp_msg=ofp.OFPT_ERROR, timeout=5) self.assertTrue(response is not None, 'Switch did not reply with error message') self.assertTrue(response.type==ofp.OFPET_BAD_REQUEST, 'Error type is not OFPET_BAD_REQUEST') self.assertTrue(response.code==ofp.OFPBRC_BAD_VERSION, 'Error code is not OFPBRC_BAD_VERSION')
def verify_flowstats(self, match, byte_count=None, packet_count=None): ''' Ensures that packet_count packets and byte_count bytes have been recorded and are advertised by dut. ''' stat_req = message.flow_stats_request() stat_req.match = match stat_req.table_id = 0xff stat_req.out_port = ofp.OFPP_NONE 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=5) self.assertTrue(response is not None, "No response to stats request") packet_counter = 0 byte_counter = 0 sleep(1) for item in response.stats: packet_counter += item.packet_count byte_counter += item.byte_count logging.info("packet_counter " + str(item.packet_count) + " packets") logging.info("byte_counter " + str(item.byte_count) + " bytes") if packet_count != None and packet_count != packet_counter: continue if byte_count != None and byte_count != byte_counter: continue break counter = [byte_counter, byte_counter + 20] if packet_count != None: self.assertEqual( packet_count, packet_counter, "Expected packet count of {0} recived {1} instead.".format( packet_count, packet_counter)) if byte_count != None: self.assertIn( byte_count, counter, "Expected byte count of {0} received {1} instead.".format( byte_count, counter))
def runTest(self): logging = get_logger() logging.info("Running Grp60No30 DurationPerFlow test") of_ports = config["port_map"].keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") #Clear switch state rc = delete_all_flows(self.controller) self.assertEqual(rc, 0, "Failed to delete all flows") logging.info("Installing a flow entry") #Create a flow with match on ingress_port (pkt, match) = wildcard_all_except_ingress(self, of_ports) #Create flow_stats request test_timeout = 30 stat_req = message.flow_stats_request() stat_req.match = match stat_req.table_id = 0xff stat_req.out_port = ofp.OFPP_NONE flow_stats_gen_ts = range(10, test_timeout, 10) for ts in range(0, test_timeout): if ts in flow_stats_gen_ts: logging.info("Sending a flow stats request") response, pkt = self.controller.transact(stat_req) self.assertTrue(response is not None, "No response to stats request") self.assertTrue( len(response.stats) == 1, "Did not receive flow stats reply") stat = response.stats[0] self.assertTrue(stat.duration_sec == ts, "Flow stats reply incorrect") logging.info("Duration of flow is " + str(stat.duration_sec) + str(stat.duration_nsec)) sleep(1)
def runTest(self): logging = get_logger() logging.info("Running Grp60No40 Duration (nsecs).") dataplane_ports = config["port_map"].keys() dataplane_ports.sort() self.assertTrue(len(dataplane_ports) > 1, "Not enough ports for test.") logging.info("Clearing switch state...") rc = delete_all_flows(self.controller) self.assertEqual(rc, 0, "Failed to delete all flows.") logging.info("Installing flow entry that matches on in_port.") (pkt,match) = wildcard_all_except_ingress(self, dataplane_ports) req = message.flow_stats_request() req.match= match req.table_id = 0xff req.out_port = ofp.OFPP_NONE duration_verifications = 5 previous_duration = (-1, -1) for v in range(0, duration_verifications): logging.info("Sending ofp_stats_request of type ofp.OFPST_FLOW") res, pkt = self.controller.transact(req) self.assertTrue(res is not None, "No ofp_stats_reply message received in response to ofp_stats_request.") self.assertTrue(res.type == ofp.OFPST_FLOW, "Expected ofp_stats_reply of type ofp.OFPST_FLOW, got {0}".format(res.type)) self.assertTrue(len(res.stats) == 1, "Received {0} ofp_flow_stats in the ofp_stats_reply message, but expected exactly 1".format(len(res.stats))) logging.info("Comparing duration in nsecs from ofp_flow_stats to previous duration in nsecs.") duration = (res.stats[0].duration_sec, res.stats[0].duration_nsec) if duration[1] < previous_duration[1]: self.assertGreater(duration[0], previous_duration[0], "Duration in nsecs was less than previous duration in nsecs, but the duration in secs was not greater than the previous duration in secs.") else: # In the case that a switch can't report in # millisecond granularity, we expect # duration_nsec to be reported as 0xffffffff. if duration[1] == previous_duration[1] and duration[1] == 4294967295: logging.info("Duration in nsec is not supported. Reported as -1 or 0xffffffff") return self.assertNotEqual(duration[1], previous_duration[1], "ofp_flow_stats.duration_nsec {0} was the same as the previous duration_nsec {1}.".format(duration, previous_duration)) previous_duration = duration time.sleep(1.5)
def Verify_FlowStats(self,match,stats_byte_count=0,stats_packet_count=0): # Verify Flow_Stats # Send Flow_Stats_Request request = message.flow_stats_request() request.out_port = ofp.OFPP_NONE request.table_id = 0xff request.match = match response, pkt = self.controller.transact(request, timeout=1) self.assertTrue(response is not None, "Did not get response") byte_count = 0 packet_count = 0 #Verify byte_count and packet_count in the reply for stat in response.stats: byte_count += stat.byte_count packet_count += stat.packet_count self.assertEqual(stats_byte_count,byte_count, "Byte counter is incorrect") self.assertEqual(stats_packet_count,packet_count, "Packet counter is incorrect")
def runTest(self): logging.info("Running DurationPerFlow test") of_ports = config["port_map"].keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") #Clear switch state rc = delete_all_flows(self.controller) self.assertEqual(rc, 0, "Failed to delete all flows") logging.info("Insert any flow") logging.info("Send Flow_stats request after n sec intervals") logging.info("Verify duration_sec and nsec counters are incrementing in accordance with the life of flow") #Create a flow with match on ingress_port (pkt,match) = wildcard_all_except_ingress(self,of_ports) #Create flow_stats request test_timeout = 30 stat_req = message.flow_stats_request() stat_req.match= match stat_req.table_id = 0xff stat_req.out_port = ofp.OFPP_NONE flow_stats_gen_ts = range (10,test_timeout,10) for ts in range(0,test_timeout): if ts in flow_stats_gen_ts: response, pkt = self.controller.transact(stat_req) self.assertTrue(response is not None,"No response to stats request") self.assertTrue(len(response.stats) == 1,"Did not receive flow stats reply") stat = response.stats[0] self.assertTrue(stat.duration_sec == ts,"Flow stats reply incorrect") logging.info("Duration of flow is " + str(stat.duration_sec) + str(stat.duration_nsec)) sleep(1)
def runTest(self): table_id = testutils.EX_L2_TABLE of_ports = exact_port_map.keys() egr_port = of_ports[0] pkt = testutils.simple_tcp_packet(dl_src='22:22:22:22:22:22', dl_dst='22:22:22:22:22:22') pkt_metadata = { 'metadata_val': 0x1122334455667788, 'metadata_msk': 0xFFFFFFFFFFFFFFFF } request = testutils.flow_msg_create(self, pkt, pkt_metadata, egr_port=egr_port, table_id=table_id) testutils.flow_msg_install(self, request) #"delete it" request_del = testutils.flow_msg_create( self, pkt, match_fields=request.match_fields, egr_port=egr_port, table_id=table_id) request_del.command = ofp.OFPFC_DELETE testutils.ofmsg_send(self, request_del) #'read it back , returns blank;' stat_req = message.flow_stats_request() stat_req.buffer_id = 0xffffffff stat_req.table_id = table_id stat_req.out_port = ofp.OFPP_ANY stat_req.out_group = ofp.OFPG_ANY stat_req.match_fields = request.match_fields response, _ = self.controller.transact(stat_req, timeout=2) self.assertTrue(isinstance(response, message.flow_stats_reply), "Not a flow_stats_reply") self.assertEqual(len(response.stats), 0, "len of stats is:" + str(len(response.stats)))
def verify_flowstats(self,match,byte_count=None,packet_count=None): # 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 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=5) self.assertTrue(response is not None,"No response to stats request") packet_counter = 0 byte_counter = 0 sleep(1) for item in response.stats: packet_counter += item.packet_count byte_counter += item.byte_count logging.info("Recieved" + str(item.packet_count) + " packets") logging.info("Received " + str(item.byte_count) + "bytes") if packet_count != None and packet_count != packet_counter: continue if byte_count != None and byte_count != byte_counter: continue break if packet_count != None : self.assertEqual(packet_count,item.packet_count,"packet_count counter is not incremented correctly") if byte_count != None : self.assertEqual(byte_count,item.byte_count,"byte_count counter is not incremented correctly")
def runTest(self): basic_logger.info("Running StatsGet") basic_logger.info("Inserting trial flow") request = message.flow_mod() request.buffer_id = 0xffffffff for i in range(1,5): request.priority = i*1000 basic_logger.debug("Adding flow %d" % i) rv = self.controller.message_send(request) self.assertTrue(rv != -1, "Failed to insert test flow %d" % i) basic_logger.info("Removing all flows") testutils.delete_all_flows(self.controller, basic_logger) basic_logger.info("Sending flow request") request = message.flow_stats_request() request.out_port = ofp.OFPP_ANY request.out_group = ofp.OFPG_ANY request.table_id = 0xff response, _ = self.controller.transact(request, timeout=2) self.assertTrue(response is not None, "Did not get response") self.assertTrue(isinstance(response,message.flow_stats_reply),"Not a flow_stats_reply") self.assertEqual(len(response.stats),0) basic_logger.debug(response.show())
def verify_flowstats(self,match,byte_count=None,packet_count=None): ''' Ensures that packet_count packets and byte_count bytes have been recorded and are advertised by dut. ''' stat_req = message.flow_stats_request() stat_req.match = match stat_req.table_id = 0xff stat_req.out_port = ofp.OFPP_NONE 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=5) self.assertTrue(response is not None,"No response to stats request") packet_counter = 0 byte_counter = 0 sleep(1) for item in response.stats: packet_counter += item.packet_count byte_counter += item.byte_count logging.info("packet_counter " + str(item.packet_count) + " packets") logging.info("byte_counter " + str(item.byte_count) + " bytes") if packet_count != None and packet_count != packet_counter: continue if byte_count != None and byte_count != byte_counter: continue break if packet_count != None : self.assertEqual(packet_count, packet_counter, "Expected packet count of {0} recived {1} instead.".format(packet_count, packet_counter)) if byte_count != None : self.assertEqual(byte_count, byte_counter, "Expected byte count of {0} received {1} instead.".format(byte_count, byte_counter))
def runTest(self): table_id = testutils.EX_L2_TABLE of_ports = exact_port_map.keys() egr_port = of_ports[len(of_ports)-1] pkt = testutils.simple_tcp_packet(dl_src='00:22:44:62:9b:1c', dl_dst='00:13:07:5f:61:ab') pkt_metadata = {'metadata_val':0xaa22334455667788, 'metadata_msk':0xFFFFFFFFFFFFFFFF} request = testutils.flow_msg_create(self, pkt, pkt_metadata, egr_port = egr_port, table_id = table_id) request.hard_timeout = 8 request.idle_timeout = 8 testutils.flow_msg_install(self, request) #"get flow stats" stat_req = message.flow_stats_request() stat_req.buffer_id = 0xffffffff stat_req.table_id = table_id stat_req.out_port = ofp.OFPP_ANY stat_req.out_group = ofp.OFPG_ANY stat_req.match_fields = request.match_fields response, _ = self.controller.transact(stat_req, timeout=2) self.assertTrue(isinstance(response,message.flow_stats_reply),"Not a flow_stats_reply") self.assertEqual(len(response.stats),1, "len of stats is:"+str(len(response.stats)))
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 test_timeout = 10 all_packets_received = 0 for i in range(0, test_timeout): response, pkt = self.controller.transact(stat_req, timeout=test_timeout) self.assertTrue(response is not None, "No response to stats request") for obj in response.stats: if (obj.packet_count == packet_count and obj.byte_count == byte_count): all_packets_received = 1 if all_packets_received: break sleep(1) self.assertTrue(all_packets_received, "Flow counters are incorrect")
def runTest(self): global pa_port_map of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") rc = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rc, 0, "Failed to delete all flows") pkt = testutils.simple_tcp_packet() match = parse.packet_to_flow_match(pkt) match.wildcards &= ~ofp.OFPFW_IN_PORT self.assertTrue(match is not None, "Could not generate flow match from pkt") act = action.action_output() ingress_port = of_ports[0] egress_port = of_ports[1] pa_logger.info("Ingress " + str(ingress_port) + " to egress " + str(egress_port)) match.in_port = ingress_port flow_mod_msg = message.flow_mod() flow_mod_msg.match = match flow_mod_msg.command = ofp.OFPFC_ADD flow_mod_msg.cookie = random.randint(0, 9007199254740992) flow_mod_msg.buffer_id = 0xffffffff flow_mod_msg.idle_timeout = 1 act.port = egress_port #pdb.set_trace() inst = instruction.instruction_apply_actions() self.assertTrue(inst.actions.add(act), "Could not add action") self.assertTrue(flow_mod_msg.instructions.add(inst), "Could not add action") stat_req = message.flow_stats_request() stat_req.match = match stat_req.table_id = 0xff stat_req.out_port = ofp.OFPP_ANY stat_req.out_group = ofp.OFPG_ANY testutils.do_barrier(self.controller) pa_logger.info("Sending stats request (before flow_mod insert)") rv = self.controller.message_send(stat_req) self.assertTrue(rv != -1, "Error sending flow stat req") testutils.do_barrier(self.controller) (empty_response, _) = self.controller.poll(ofp.OFPT_STATS_REPLY, 2) self.assertTrue(empty_response, "No flow_stats reply (expected empty flow_stats)") self.assertEqual(len(empty_response.stats), 0) pa_logger.info("Inserting flow") rv = self.controller.message_send(flow_mod_msg) self.assertTrue(rv != -1, "Error installing flow mod") testutils.do_barrier(self.controller) pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) (rcv_port, rcv_pkt, _) = self.dataplane.poll(timeout=2) self.assertTrue(rcv_pkt is not None, "Did not receive packet") pa_logger.debug("Packet len " + str(len(pkt)) + " in on " + str(rcv_port)) self.assertEqual(rcv_port, egress_port, "Unexpected receive port") self.assertEqual(str(pkt), str(rcv_pkt), 'Response packet does not match send packet') pa_logger.info("Sending stats request") rv = self.controller.message_send(stat_req) self.assertTrue(rv != -1, "Error sending flow stat req") testutils.do_barrier(self.controller) (response, _) = self.controller.poll(ofp.OFPT_STATS_REPLY, 2) self.assertTrue(response, "No Flow_stats reply") #print "YYY: Stats reply is \n%s" % (response.show()) self.assertEqual(len(response.stats), 1, "Did not receive flow stats reply") self.assertEqual(response.stats[0].packet_count, 1) self.assertEqual(response.stats[0].byte_count, len(rcv_pkt))
def runTest(self): global pa_port_map of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") rc = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rc, 0, "Failed to delete all flows") pkt = testutils.simple_tcp_packet() match = parse.packet_to_flow_match(pkt) match.wildcards &= ~ofp.OFPFW_IN_PORT self.assertTrue(match is not None, "Could not generate flow match from pkt") act = action.action_output() ingress_port = of_ports[0]; egress_port = of_ports[1]; pa_logger.info("Ingress " + str(ingress_port) + " to egress " + str(egress_port)) match.in_port = ingress_port flow_mod_msg = message.flow_mod() flow_mod_msg.match = match flow_mod_msg.command = ofp.OFPFC_ADD flow_mod_msg.cookie = random.randint(0,9007199254740992) flow_mod_msg.buffer_id = 0xffffffff flow_mod_msg.idle_timeout = 1 act.port = egress_port #pdb.set_trace() inst = instruction.instruction_apply_actions() self.assertTrue(inst.actions.add(act), "Could not add action") self.assertTrue(flow_mod_msg.instructions.add(inst), "Could not add action") stat_req = message.flow_stats_request() stat_req.match = match stat_req.table_id = 0xff stat_req.out_port = ofp.OFPP_ANY; stat_req.out_group = ofp.OFPG_ANY; testutils.do_barrier(self.controller) pa_logger.info("Sending stats request (before flow_mod insert)") rv = self.controller.message_send(stat_req) self.assertTrue(rv != -1, "Error sending flow stat req") testutils.do_barrier(self.controller) (empty_response, _) = self.controller.poll(ofp.OFPT_STATS_REPLY, 2) self.assertTrue(empty_response, "No flow_stats reply (expected empty flow_stats)") self.assertEqual(len(empty_response.stats),0) pa_logger.info("Inserting flow") rv = self.controller.message_send(flow_mod_msg) self.assertTrue(rv != -1, "Error installing flow mod") testutils.do_barrier(self.controller) pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) (rcv_port, rcv_pkt, _) = self.dataplane.poll(timeout=2) self.assertTrue(rcv_pkt is not None, "Did not receive packet") pa_logger.debug("Packet len " + str(len(pkt)) + " in on " + str(rcv_port)) self.assertEqual(rcv_port, egress_port, "Unexpected receive port") self.assertEqual(str(pkt), str(rcv_pkt), 'Response packet does not match send packet') pa_logger.info("Sending stats request") rv = self.controller.message_send(stat_req) self.assertTrue(rv != -1, "Error sending flow stat req") testutils.do_barrier(self.controller) (response, _) = self.controller.poll(ofp.OFPT_STATS_REPLY, 2) self.assertTrue(response, "No Flow_stats reply") #print "YYY: Stats reply is \n%s" % (response.show()) self.assertEqual(len(response.stats), 1, "Did not receive flow stats reply") self.assertEqual(response.stats[0].packet_count,1) self.assertEqual(response.stats[0].byte_count,len(rcv_pkt))
def runTest(self): logging = get_logger() logging.info("Running Grp40No30 Identical_Flows test ") of_ports = config["port_map"].keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") #Clear switch state rc = delete_all_flows(self.controller) self.assertEqual(rc, 0, "Failed to delete all flows") logging.info("Installing an all wildcarded flow") # Create and add flow-1, check on dataplane it is active. (pkt, match) = wildcard_all(self, of_ports) # Verify active_entries in table_stats_request =1 #verify_tablestats(self,expect_active=1) # Send Packet (to increment counters like byte_count and packet_count) logging.info("Sending a matching packet to increase the counters") send_packet(self, pkt, of_ports[0], of_ports[1]) # Verify Flow counters have incremented logging.info("Verifying whether the flow counters have increased") stat_req = message.flow_stats_request() stat_req.match = match stat_req.table_id = 0xff stat_req.out_port = ofp.OFPP_NONE 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") packet_counter = 0 byte_counter = 0 sleep(1) for item in response.stats: packet_counter += item.packet_count byte_counter += item.byte_count logging.info("Recieved" + str(item.packet_count) + " packets") logging.info("Received " + str(item.byte_count) + "bytes") if packet_counter == None: continue if byte_counter == None: continue break if packet_counter == None: self.assertEqual(packet_count, item.packet_count, "packet_count counter did not increment") if byte_counter == None: self.assertEqual(byte_count, item.byte_count, "byte_count counter did not increment") #Send Identical flow logging.info("Installing an identical flow") (pkt1, match1) = wildcard_all(self, of_ports) # Verify active_entries in table_stats_request =1 #verify_tablestats(self,expect_active=1) # Verify Flow counters reset logging.info("Verifying whether the flow counter have reset") verify_flowstats(self, match, byte_count=0, packet_count=0)
def runTest(self): logging = get_logger() logging.info("Running Grp40No30 Identical_Flows test ") of_ports = config["port_map"].keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") #Clear switch state rc = delete_all_flows(self.controller) self.assertEqual(rc, 0, "Failed to delete all flows") logging.info("Installing an all wildcarded flow") # Create and add flow-1, check on dataplane it is active. (pkt,match) = wildcard_all(self,of_ports) # Verify active_entries in table_stats_request =1 #verify_tablestats(self,expect_active=1) # Send Packet (to increment counters like byte_count and packet_count) logging.info("Sending a matching packet to increase the counters") send_packet(self,pkt,of_ports[0],of_ports[1]) # Verify Flow counters have incremented logging.info("Verifying whether the flow counters have increased") stat_req = message.flow_stats_request() stat_req.match = match stat_req.table_id = 0xff stat_req.out_port = ofp.OFPP_NONE 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") packet_counter = 0 byte_counter = 0 sleep(1) for item in response.stats: packet_counter += item.packet_count byte_counter += item.byte_count logging.info("Recieved" + str(item.packet_count) + " packets") logging.info("Received " + str(item.byte_count) + "bytes") if packet_counter == None : continue if byte_counter == None : continue break if packet_counter == None : self.assertEqual(packet_count,item.packet_count,"packet_count counter did not increment") if byte_counter == None : self.assertEqual(byte_count,item.byte_count,"byte_count counter did not increment") #Send Identical flow logging.info("Installing an identical flow") (pkt1,match1) = wildcard_all(self,of_ports) # Verify active_entries in table_stats_request =1 #verify_tablestats(self,expect_active=1) # Verify Flow counters reset logging.info("Verifying whether the flow counter have reset") verify_flowstats(self,match,byte_count=0,packet_count=0)
def runTest(self): logging = get_logger() logging.info("Running Grp60No40 Duration (nsecs).") dataplane_ports = config["port_map"].keys() dataplane_ports.sort() self.assertTrue(len(dataplane_ports) > 1, "Not enough ports for test.") logging.info("Clearing switch state...") rc = delete_all_flows(self.controller) self.assertEqual(rc, 0, "Failed to delete all flows.") logging.info("Installing flow entry that matches on in_port.") (pkt, match) = wildcard_all_except_ingress(self, dataplane_ports) req = message.flow_stats_request() req.match = match req.table_id = 0xff req.out_port = ofp.OFPP_NONE duration_verifications = 5 previous_duration = (-1, -1) for v in range(0, duration_verifications): logging.info("Sending ofp_stats_request of type ofp.OFPST_FLOW") res, pkt = self.controller.transact(req) self.assertTrue( res is not None, "No ofp_stats_reply message received in response to ofp_stats_request." ) self.assertTrue( res.type == ofp.OFPST_FLOW, "Expected ofp_stats_reply of type ofp.OFPST_FLOW, got {0}". format(res.type)) self.assertTrue( len(res.stats) == 1, "Received {0} ofp_flow_stats in the ofp_stats_reply message, but expected exactly 1" .format(len(res.stats))) logging.info( "Comparing duration in nsecs from ofp_flow_stats to previous duration in nsecs." ) duration = (res.stats[0].duration_sec, res.stats[0].duration_nsec) if duration[1] < previous_duration[1]: self.assertGreater( duration[0], previous_duration[0], "Duration in nsecs was less than previous duration in nsecs, but the duration in secs was not greater than the previous duration in secs." ) else: # In the case that a switch can't report in # millisecond granularity, we expect # duration_nsec to be reported as 0xffffffff. if duration[1] == previous_duration[1] and duration[ 1] == 4294967295: logging.info( "Duration in nsec is not supported. Reported as -1 or 0xffffffff" ) return self.assertNotEqual( duration[1], previous_duration[1], "ofp_flow_stats.duration_nsec {0} was the same as the previous duration_nsec {1}." .format(duration, previous_duration)) previous_duration = duration time.sleep(1.5)
def runTest(self): global pa_port_map of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") rc = delete_all_flows(self.controller, pa_logger) self.assertEqual(rc, 0, "Failed to delete all flows") pkt = simple_tcp_packet() match = parse.packet_to_flow_match(pkt) match.wildcards &= ~ofp.OFPFW_IN_PORT self.assertTrue(match is not None, "Could not generate flow match from pkt") act = action.action_output() ingress_port = of_ports[0] egress_port = of_ports[1] pa_logger.info("Ingress " + str(ingress_port) + " to egress " + str(egress_port)) match.in_port = ingress_port flow_mod_msg = message.flow_mod() flow_mod_msg.match = match flow_mod_msg.cookie = random.randint(0, 9007199254740992) flow_mod_msg.buffer_id = 0xFFFFFFFF flow_mod_msg.idle_timeout = 1 act.port = egress_port self.assertTrue(flow_mod_msg.actions.add(act), "Could not add action") stat_req = message.flow_stats_request() stat_req.match = match stat_req.table_id = 0xFF stat_req.out_port = ofp.OFPP_NONE do_barrier(self.controller) pa_logger.info("Sending stats request") rv = self.controller.message_send(stat_req) self.assertTrue(rv != -1, "Error sending flow stat req") do_barrier(self.controller) (response, raw) = self.controller.poll(ofp.OFPT_STATS_REPLY, 2) pa_logger.info("Inserting flow") rv = self.controller.message_send(flow_mod_msg) self.assertTrue(rv != -1, "Error installing flow mod") do_barrier(self.controller) pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) (rcv_port, rcv_pkt, pkt_time) = self.dataplane.poll(timeout=2) self.assertTrue(rcv_pkt is not None, "Did not receive packet") pa_logger.debug("Packet len " + str(len(pkt)) + " in on " + str(rcv_port)) self.assertEqual(rcv_port, egress_port, "Unexpected receive port") self.assertEqual(str(pkt), str(rcv_pkt), "Response packet does not match send packet") pa_logger.info("Sending stats request") rv = self.controller.message_send(stat_req) self.assertTrue(rv != -1, "Error sending flow stat req") do_barrier(self.controller) (response, raw) = self.controller.poll(ofp.OFPT_STATS_REPLY, 2) # print "YYY: Stats reply is \n%s" % (response.show()) self.assertTrue(len(response.stats) == 1, "Did not receive flow stats reply")