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): ing_port = flow_mods_port_map.keys()[0] out_port1 = flow_mods_port_map.keys()[1] out_port2 = flow_mods_port_map.keys()[2] pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) fm_orig = testutils.flow_msg_create(self, pkt, ing_port=ofp.OFPP_ANY, egr_port=out_port1, table_id=2) fm_new = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port2, table_id=2) fm_new.command = ofp.OFPFC_MODIFY_STRICT testutils.ofmsg_send(self, fm_orig) testutils.ofmsg_send(self, fm_new) flow_stats = testutils.flow_stats_get(self) #print(flow_stats.show()) self.assertEqual(len(flow_stats.stats),1, "Expected only one flow_mod") #fail to modify and instruction will remain the same stat = flow_stats.stats[0] self.assertEqual(stat.match, fm_orig.match) self.assertEqual(stat.instructions, fm_orig.instructions)
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): basic_logger.info("Running TableStats") testutils.delete_all_flows(self.controller, self.logger) basic_logger.info("Sending table stats request") request = message.table_stats_request() response, _ = self.controller.transact(request, timeout=2) # delete everything, so there should be no entries self.assertEqual(self.get_first_table_active_entries(response), 0) # add two entries to first table m1 = testutils.match_all_generate() m1.dl_type = 0x800 m1.wildcards ^= ofp.OFPFW_DL_TYPE fm1 = testutils.flow_msg_create(self, None, match=m1, egr_port=2) rv = self.controller.message_send(fm1) self.assertEqual(rv, 0) m2 = testutils.match_all_generate() m2.dl_type = 0x806 m2.wildcards ^= ofp.OFPFW_DL_TYPE fm2 = testutils.flow_msg_create(self, None, match=m2, egr_port=2) rv = self.controller.message_send(fm2) self.assertEqual(rv, 0) testutils.do_barrier(self.controller) response, _ = self.controller.transact(request, timeout=2) self.assertEqual(self.get_first_table_active_entries(response), 2)
def runTest(self): ing_port = flow_mods_port_map.keys()[0] out_port1 = flow_mods_port_map.keys()[1] out_port2 = flow_mods_port_map.keys()[2] pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) fm_orig = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port1) fm_new = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port2) fm_new.command = ofp.OFPFC_MODIFY_STRICT rv = self.controller.message_send(fm_orig) self.assertEqual(rv, 0, "Failed to insert 1st flow_mod") testutils.do_barrier(self.controller) rv = self.controller.message_send(fm_new) testutils.do_barrier(self.controller) self.assertEqual(rv, 0, "Failed to insert 2nd flow_mod") flow_stats = testutils.flow_stats_get(self) self.assertEqual(len(flow_stats.stats),1, "Expected only one flow_mod") stat = flow_stats.stats[0] self.assertEqual(stat.match, fm_new.match) self.assertEqual(stat.instructions, fm_new.instructions)
def runTest(self): ing_port = flow_mods_port_map.keys()[0] out_port1 = flow_mods_port_map.keys()[1] out_port2 = flow_mods_port_map.keys()[2] pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) fm_orig = testutils.flow_msg_create(self, pkt, ing_port=ofp.OFPP_ANY, egr_port=out_port1, table_id=2) fm_new = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port2, table_id=2) fm_new.command = ofp.OFPFC_MODIFY_STRICT testutils.ofmsg_send(self, fm_orig) testutils.ofmsg_send(self, fm_new) flow_stats = testutils.flow_stats_get(self) #print(flow_stats.show()) self.assertEqual(len(flow_stats.stats), 1, "Expected only one flow_mod") #fail to modify and instruction will remain the same stat = flow_stats.stats[0] self.assertEqual(stat.match, fm_orig.match) self.assertEqual(stat.instructions, fm_orig.instructions)
def runTest(self): of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # For making the test simpler... ing_port = of_ports[0] egr_port = of_ports[1] check_expire_tbl0 = False check_expire_tbl1 = False # Build the ingress packet pkt = testutils.simple_tcp_packet(**self.base_pkt_params) # Set action for the first table for item_tbl0 in self.start_pkt_params: tbl0_pkt_params = self.base_pkt_params.copy() tbl0_pkt_params[item_tbl0] = self.mod_pkt_params[item_tbl0] act = testutils.action_generate(self, item_tbl0, tbl0_pkt_params) action_list = [act] inst_1 = instruction.instruction_apply_actions() inst_2 = instruction.instruction_goto_table() inst_2.table_id = 1 inst_list = [inst_1, inst_2] request0 = testutils.flow_msg_create(self, pkt, ing_port=ing_port, instruction_list=inst_list, action_list=action_list, check_expire=check_expire_tbl0, table_id=0) exp_pkt = testutils.simple_tcp_packet(**tbl0_pkt_params) request1 = testutils.flow_msg_create(self, exp_pkt, ing_port=ing_port, check_expire=check_expire_tbl1, table_id=1, egr_port=egr_port) # Insert two flows self.logger.debug("Inserting flows: Modify-field: " + item_tbl0) testutils.flow_msg_install(self, request0) testutils.flow_msg_install(self, request1) # Send pkt self.logger.debug("Send packet: " + str(ing_port) + " to " + str(egr_port)) self.dataplane.send(ing_port, str(pkt)) #@todo Not all HW supports both pkt and byte counters #@todo We shouldn't expect the order of coming response.. if check_expire_tbl0: flow_removed_verify(self, request0, pkt_count=1, byte_count=pktlen) if check_expire_tbl1: flow_removed_verify(self, request1, pkt_count=1, byte_count=exp_pktlen) # Receive and verify pkt testutils.receive_pkt_verify(self, egr_port, exp_pkt)
def runTest(self): ing_port = flow_mods_port_map.keys()[0] egr_port = flow_mods_port_map.keys()[1] table_id = testutils.EX_L3_TABLE flow_count = 10 testutils.delete_all_flows_one_table(self.controller, self.logger, table_id) match_fields_ls = [] ipv6_src_addr = 'fe80::2420:52ff:fe8f:5188' metadata_val = 0xaa22334455667788 for i in range(flow_count): match_fields_ls.append(match_list()) match_fields_ls[i].add(match.eth_type(testutils.IPV6_ETHERTYPE)) match_fields_ls[i].add( match.ipv6_src(ipaddr.IPv6Address(ipv6_src_addr))) ipv6_dst_addr = 'fe80::2420:52ff:fe8f:' + str(5190 + i) match_fields_ls[i].add( match.ipv6_dst(ipaddr.IPv6Address(ipv6_dst_addr))) match_fields_ls[i].add(match.metadata(metadata_val)) request = testutils.flow_msg_create( self, None, ing_port=ing_port, match_fields=match_fields_ls[i], egr_port=egr_port, table_id=table_id) testutils.flow_msg_install(self, request, False) match_fields = match_list() match_fields.add(match.eth_type(testutils.IPV6_ETHERTYPE)) match_fields.add(match.ipv6_src(ipaddr.IPv6Address(ipv6_src_addr))) response = testutils.flow_stats_get(self, table_id=table_id) self.assertTrue( len(response.stats) == flow_count, 'Did not add all flows successfully! Get table entry num is %d' % len(response.stats)) request = testutils.flow_msg_create(self, None, None, ing_port, match_fields, table_id=table_id) request.command = ofp.OFPFC_DELETE testutils.flow_msg_install(self, request, False) response = testutils.flow_stats_get(self, table_id=table_id) self.assertTrue( len(response.stats) == 0, 'Switch did not del the flow entry! Current table entry num is %d' % len(response.stats))
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): # Config of_ports = ipv6_port_map.keys() of_ports.sort() ing_port = of_ports[0] egr_port = of_ports[2] table_id = testutils.WC_ACL_TABLE # Remove flows rc = testutils.delete_all_flows(self.controller, ipv6_logger) self.assertEqual(rc, 0, "Failed to delete all flows") # Add entry match pkt = testutils.simple_ipv6_packet(tcp_sport=80, tcp_dport=8080) request = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=egr_port, table_id=table_id) testutils.flow_msg_install(self, request) #Send packet ipv6_logger.info("Sending IPv6 packet to " + str(ing_port)) ipv6_logger.debug("Data: " + str(pkt).encode('hex')) self.dataplane.send(ing_port, str(pkt)) #Receive packet exp_pkt = testutils.simple_ipv6_packet(tcp_sport=80, tcp_dport=8080) testutils.receive_pkt_verify(self, egr_port, exp_pkt) #Remove flows rc = testutils.delete_all_flows(self.controller, ipv6_logger) self.assertEqual(rc, 0, "Failed to delete all flows")
def runTest(self): of_ports = ipv6_port_map.keys() of_ports.sort() ing_port = of_ports[0] egr_port = of_ports[2] table_id = testutils.WC_L3_TABLE # Remove all entries Add entry match all rc = testutils.delete_all_flows(self.controller, self.logger) self.assertEqual(rc, 0, "Failed to delete all flows") rv = testutils.set_table_config(self, table_id) self.assertEqual(rv, 0, "Failed to set table config") # Add entry match pkt = testutils.simple_ipv6_packet() request = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=egr_port, table_id=table_id) testutils.flow_msg_install(self, request) #Send packet self.logger.info("Sending IPv6 packet to " + str(ing_port)) self.logger.debug("Data: " + str(pkt).encode('hex')) self.dataplane.send(ing_port, str(pkt)) #Receive packet testutils.receive_pkt_verify(self, egr_port, pkt) #Remove flows rc = testutils.delete_all_flows(self.controller, self.logger) self.assertEqual(rc, 0, "Failed to delete all flows")
def runTest(self): """ ** Currently, same scenario with "NoGoto" ** Add four flow entries: First Table; Match IP Src A; goto Second Table Second Table; Match IP Src A; send to 1, goto Third Table Third Table; Match IP Src A; do nothing // match but stop pipeline Fourth Table; Match IP Src A; send to 2 // not match, just a fake Then send in 2 packets: IP A, TCP C; expect out port 1 IP A, TCP B; expect out port 1 """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up first match testutils.write_goto(self, testutils.WC_ACL_TABLE, testutils.WC_SERV_TABLE) # Set up second match testutils.write_goto_output(self, testutils.WC_SERV_TABLE, testutils.EX_L2_TABLE, of_ports[0], of_ports[2]) # Set up third match, "Empty Instruction" pkt = testutils.simple_tcp_packet() request = testutils.flow_msg_create(self, pkt, ing_port = of_ports[2], table_id = testutils.EX_L2_TABLE) testutils.flow_msg_install(self, request) # Set up fourth match testutils.write_output(self, testutils.EX_VLAN_TABLE, of_ports[1]) # Generate a packet matching flow 1, 2, and 3; rcv on port[0] testutils.reply_check_dp(self, tcp_sport=1234, ing_port = of_ports[2], egr_port = of_ports[0])
def runTest(self): of_ports = exact_port_map.keys() ing_port = of_ports[0] egr_port = of_ports[1] table_id = testutils.EX_ACL_TABLE "clear swtich;" testutils.delete_all_flows(self.controller, self.logger) "make test packet;" pkt = testutils.simple_tcp_packet() "construct flow entry" match_ls = testutils.packet_to_exact_flow_match( pkt, None, table_id, ing_port) flow_add = testutils.flow_msg_create(self, pkt, match_fields=match_ls, egr_port=egr_port, table_id=table_id) testutils.ofmsg_send(self, flow_add) "read flow back;" response = testutils.flow_stats_get(self, match_ls, table_id) self.assertTrue(len(response.stats) != 0, "stats len is 0") "send a packet from ing_port " self.dataplane.send(ing_port, str(pkt)) "poll from the egr_port port" testutils.receive_pkt_verify(self, egr_port, pkt)
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): table_id = testutils.EX_L2_TABLE of_ports = exact_port_map.keys() egr_port = of_ports[1] pkt = testutils.simple_tcp_packet(dl_src='08:02:ff:34:88:99', dl_dst='22:22:ed:22:5f:1a') request = testutils.flow_msg_create(self, pkt, egr_port=egr_port, table_id=table_id) for obj in request.match_fields.tlvs: if obj.field == ofp.OFPXMT_OFB_METADATA: obj.value = 0x9922334455667788 request.idle_timeout = 1 request.flags |= ofp.OFPFF_SEND_FLOW_REM testutils.flow_msg_install(self, request) #print(request.show()) (response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 3) self.assertTrue(response is not None, 'Did not receive flow removed message ') self.assertEqual(request.cookie, response.cookie, 'Cookies do not match') self.assertEqual( ofp.OFPRR_IDLE_TIMEOUT, response.reason, 'Flow table entry removal reason is not idle_timeout')
def runTest(self): of_ports = testutils.clear_switch(self, exact_port_map.keys(), exact_logger) #zhaoxiuchu table_id = testutils.EX_L2_TABLE of_ports = exact_port_map.keys() egr_port = of_ports[1] pkt = testutils.simple_tcp_packet(dl_src='08:02:03:04:88:99', dl_dst='22:22:22:22:22:22') pkt_metadata = { 'metadata_val': 0xad22332e6f667588, 'metadata_msk': 0xFFFFFFFFFFFFFFFF } request = testutils.flow_msg_create(self, pkt, pkt_metadata, egr_port=egr_port, table_id=table_id) request.hard_timeout = 1 request.flags |= ofp.OFPFF_SEND_FLOW_REM testutils.flow_msg_install(self, request) #print(request.show()) (response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 3) self.assertTrue(response is not None, 'Did not receive flow removed message ') self.assertEqual(request.cookie, response.cookie, 'Cookies do not match') self.assertEqual( ofp.OFPRR_HARD_TIMEOUT, response.reason, 'Flow table entry removal reason is not idle_timeout')
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 2, "Not enough ports for test") pkt = testutils.simple_tcp_packet() for ingress_port in of_ports: rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") pa_logger.info("Ingress " + str(ingress_port) + " all non-ingress ports") actions = [] for egress_port in of_ports: act = action.action_output() if egress_port == ingress_port: continue act.port = egress_port actions.append(act) request = testutils.flow_msg_create(self, pkt, ing_port=ingress_port, action_list=actions, inst_app_flag=testutils.APPLY_ACTIONS_INSTRUCTION) pa_logger.info("Inserting flow") testutils.ofmsg_send(self, request) pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) yes_ports = set(of_ports).difference([ingress_port]) testutils.receive_pkt_check(self.dataplane, pkt, yes_ports, [ingress_port], self, pa_logger)
def runTest(self): testutils.clear_switch(self,group_port_map,group_logger) # self.clear_switch() group_add_msg = \ create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_INDIRECT, group_id = 1, buckets = [ create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 2000), create_action(action = ofp.OFPAT_OUTPUT, port = 2) ]) ]) self.send_ctrl_exp_noerror(group_add_msg, 'group add') packet_in = testutils.simple_tcp_packet(tcp_sport=1000) packet_out = testutils.simple_tcp_packet(tcp_sport=2000) flow_add_msg = \ testutils.flow_msg_create(self,packet_in,ing_port = 1,action_list = [ create_action(action = ofp.OFPAT_GROUP, group_id = 1) ]) self.send_ctrl_exp_noerror(flow_add_msg, 'flow add') self.send_data(packet_in, 1) self.recv_data(2, packet_out)
def runTest(self): ing_port = flow_mods_port_map.keys()[0] out_port1 = flow_mods_port_map.keys()[1] out_port2 = flow_mods_port_map.keys()[2] pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) fm_orig = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port1) inst = None inst = instruction.instruction_write_actions()#instruct is the same, action is different act = action.action_output() act.port = out_port2 rv = inst.actions.add(act) self.assertTrue(rv, "Could not add action" + act.show()) fm_orig.instructions.add(inst) #print(fm_orig.show()) testutils.ofmsg_send(self, fm_orig) (response, raw) = self.controller.poll(ofp.OFPT_ERROR, 5) self.assertTrue(response is not None, 'No error message received') self.assertEqual(ofp.OFPET_BAD_INSTRUCTION, response.type, 'Error message type mismatch: ' + str(ofp.OFPET_BAD_INSTRUCTION,) + " != " + str(response.type)) self.assertEqual(ofp.OFPBIC_UNKNOWN_INST, response.code, 'Error message code mismatch: ' + str(ofp.OFPBIC_UNKNOWN_INST) + " != " + str(response.code))
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") pkt = testutils.simple_tcp_packet() for ingress_port in of_ports: rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") pa_logger.info("Ingress " + str(ingress_port) + " to all ports") request = testutils.flow_msg_create(self, pkt, ing_port=ingress_port, egr_port=ofp.OFPP_ALL) pa_logger.info("Inserting flow") testutils.ofmsg_send(self, request) pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) yes_ports = set(of_ports).difference([ingress_port]) testutils.receive_pkt_check(self.dataplane, pkt, yes_ports, [ingress_port], self, pa_logger)
def runTest(self): ing_port = flow_mods_port_map.keys()[0] out_port1 = ofp.OFPP_ALL pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) fm_orig = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port1)#flood inst = None inst = instruction.instruction_apply_actions() act = action.action_output() act.port = ofp.OFPP_IN_PORT #fwd to ingress rv = inst.actions.add(act) self.assertTrue(rv, "Could not add action" + act.show()) fm_orig.instructions.add(inst) #print(fm_orig.show()) testutils.ofmsg_send(self, fm_orig) (response, raw) = self.controller.poll(ofp.OFPT_ERROR, 2) self.assertTrue(response is None, 'Receive error message') #user sends packet self.dataplane.send(ing_port, str(pkt)) testutils.do_barrier(self.controller) #verify pkt for of_port in flow_mods_port_map.keys(): testutils.receive_pkt_verify(self, of_port, pkt)
def runTest(self): ing_port = flow_mods_port_map.keys()[0] out_port1 = ofp.OFPP_ALL pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) fm_orig = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port1) #flood inst = None inst = instruction.instruction_apply_actions() act = action.action_output() act.port = ofp.OFPP_IN_PORT #fwd to ingress rv = inst.actions.add(act) self.assertTrue(rv, "Could not add action" + act.show()) fm_orig.instructions.add(inst) #print(fm_orig.show()) testutils.ofmsg_send(self, fm_orig) (response, raw) = self.controller.poll(ofp.OFPT_ERROR, 2) self.assertTrue(response is None, 'Receive error message') #user sends packet self.dataplane.send(ing_port, str(pkt)) testutils.do_barrier(self.controller) #verify pkt for of_port in flow_mods_port_map.keys(): testutils.receive_pkt_verify(self, of_port, pkt)
def runTest(self): of_ports = ipv6_port_map.keys() of_ports.sort() ing_port = of_ports[0] egr_port = of_ports[2] table_id = testutils.WC_L3_TABLE # Remove all entries Add entry match all rc = testutils.delete_all_flows(self.controller, self.logger) self.assertEqual(rc, 0, "Failed to delete all flows") rv = testutils.set_table_config(self, table_id) self.assertEqual(rv, 0, "Failed to set table config") # Add entry match pkt = testutils.simple_ipv6_packet() request = testutils.flow_msg_create(self, pkt, ing_port = ing_port, egr_port = egr_port, table_id = table_id) testutils.flow_msg_install(self, request) #Send packet self.logger.info("Sending IPv6 packet to " + str(ing_port)) self.logger.debug("Data: " + str(pkt).encode('hex')) self.dataplane.send(ing_port, str(pkt)) #Receive packet testutils.receive_pkt_verify(self, egr_port, pkt) #Remove flows rc = testutils.delete_all_flows(self.controller, self.logger) self.assertEqual(rc, 0, "Failed to delete all flows")
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 2, "Not enough ports for test") pkt = testutils.simple_tcp_packet() for ingress_port in of_ports: rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") pa_logger.info("Ingress " + str(ingress_port) + " to all ports") actions = [] for egress_port in of_ports: act = action.action_output() if egress_port == ingress_port: act.port = ofp.OFPP_IN_PORT else: act.port = egress_port actions.append(act) request = testutils.flow_msg_create(self, pkt, ingress_port, action_list=actions) request.buffer_id = 0xffffffff # pa_logger.info(request.show()) pa_logger.info("Inserting flow") rv = self.controller.message_send(request) 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)) testutils.receive_pkt_check(self.dataplane, pkt, of_ports, [], self, pa_logger)
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 2, "Not enough ports for test") pkt = testutils.simple_tcp_packet() for ingress_port in of_ports: rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") pa_logger.info("Ingress " + str(ingress_port) + " all non-ingress ports") actions = [] for egress_port in of_ports: act = action.action_output() if egress_port == ingress_port: continue act.port = egress_port actions.append(act) request = testutils.flow_msg_create( self, pkt, ing_port=ingress_port, action_list=actions, inst_app_flag=testutils.APPLY_ACTIONS_INSTRUCTION) pa_logger.info("Inserting flow") testutils.ofmsg_send(self, request) pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) yes_ports = set(of_ports).difference([ingress_port]) testutils.receive_pkt_check(self.dataplane, pkt, yes_ports, [ingress_port], self, pa_logger)
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") pkt = testutils.simple_tcp_packet() act_all = action.action_output() act_all.port = ofp.OFPP_ALL act_ing = action.action_output() act_ing.port = ofp.OFPP_IN_PORT actions = [ act_all, act_ing] for ingress_port in of_ports: rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") pa_logger.info("Ingress " + str(ingress_port) + " to all ports") flow_mod = testutils.flow_msg_create(self, pkt, ing_port=ingress_port, action_list=actions, inst_app_flag=testutils.APPLY_ACTIONS_INSTRUCTION ) pa_logger.info(flow_mod.show()) pa_logger.info("Inserting flow") testutils.ofmsg_send(self, flow_mod) pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) testutils.receive_pkt_check(self.dataplane, pkt, of_ports, [], self, pa_logger)
def handleFlow(self, pkttype='TCP'): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") if (pkttype == 'ICMP'): pkt = testutils.simple_icmp_packet() table_id = testutils.EX_ICMP_TABLE else: pkt = testutils.simple_tcp_packet() table_id = testutils.WC_ACL_TABLE for idx in range(len(of_ports)): rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") testutils.set_table_config(self, table_id, ofp.OFPTC_TABLE_MISS_CONTINUE) ingress_port = of_ports[idx] egress_port = of_ports[(idx + 1) % len(of_ports)] pa_logger.info("Ingress " + str(ingress_port) + " to egress " + str(egress_port)) #controller send flow mod to switch request = testutils.flow_msg_create(self,pkt, ing_port=ingress_port, egr_port=egress_port, table_id=table_id) testutils.flow_msg_install(self, request) #user send pkt to switch pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) testutils.receive_pkt_verify(self, egress_port, pkt)
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") pkt = testutils.simple_tcp_packet() act_all = action.action_output() act_all.port = ofp.OFPP_ALL act_ing = action.action_output() act_ing.port = ofp.OFPP_IN_PORT actions = [ act_all, act_ing] for ingress_port in of_ports: rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") pa_logger.info("Ingress " + str(ingress_port) + " to all ports") flow_mod = testutils.flow_msg_create(self, pkt, ing_port=ingress_port, action_list=actions, wildcards=~ofp.OFPFW_IN_PORT) flow_mod.buffer_id = 0xffffffff pa_logger.info(flow_mod.show()) pa_logger.info("Inserting flow") rv = self.controller.message_send(flow_mod) 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)) testutils.receive_pkt_check(self.dataplane, pkt, of_ports, [], self, pa_logger)
def runTest(self): ing_port = flow_mods_port_map.keys()[0] out_port1 = flow_mods_port_map.keys()[1] out_port2 = flow_mods_port_map.keys()[2] pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) fm_orig = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port1) inst = None inst = instruction.instruction_write_actions( ) #instruct is the same, action is different act = action.action_output() act.port = out_port2 rv = inst.actions.add(act) self.assertTrue(rv, "Could not add action" + act.show()) fm_orig.instructions.add(inst) #print(fm_orig.show()) testutils.ofmsg_send(self, fm_orig) (response, raw) = self.controller.poll(ofp.OFPT_ERROR, 5) self.assertTrue(response is not None, 'No error message received') self.assertEqual( ofp.OFPET_BAD_INSTRUCTION, response.type, 'Error message type mismatch: ' + str(ofp.OFPET_BAD_INSTRUCTION, ) + " != " + str(response.type)) self.assertEqual( ofp.OFPBIC_UNKNOWN_INST, response.code, 'Error message code mismatch: ' + str(ofp.OFPBIC_UNKNOWN_INST) + " != " + str(response.code))
def handleFlow(self, pkttype='TCP'): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") if (pkttype == 'ICMP'): pkt = testutils.simple_icmp_packet() table_id = testutils.EX_ICMP_TABLE else: pkt = testutils.simple_tcp_packet() table_id = testutils.WC_ACL_TABLE for idx in range(len(of_ports)): rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") testutils.set_table_config(self, table_id, ofp.OFPTC_TABLE_MISS_CONTINUE) ingress_port = of_ports[idx] egress_port = of_ports[(idx + 1) % len(of_ports)] pa_logger.info("Ingress " + str(ingress_port) + " to egress " + str(egress_port)) #controller send flow mod to switch request = testutils.flow_msg_create(self, pkt, ing_port=ingress_port, egr_port=egress_port, table_id=table_id) testutils.flow_msg_install(self, request) #user send pkt to switch pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) testutils.receive_pkt_verify(self, egress_port, pkt)
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") pkt = testutils.simple_tcp_packet() act_all = action.action_output() act_all.port = ofp.OFPP_ALL act_ing = action.action_output() act_ing.port = ofp.OFPP_IN_PORT actions = [act_all, act_ing] for ingress_port in of_ports: rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") pa_logger.info("Ingress " + str(ingress_port) + " to all ports") flow_mod = testutils.flow_msg_create( self, pkt, ing_port=ingress_port, action_list=actions, inst_app_flag=testutils.APPLY_ACTIONS_INSTRUCTION) pa_logger.info(flow_mod.show()) pa_logger.info("Inserting flow") testutils.ofmsg_send(self, flow_mod) pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) testutils.receive_pkt_check(self.dataplane, pkt, of_ports, [], self, pa_logger)
def runTest(self): for of_port in sdn_port_map.keys(): ing_port = of_port for egr_port in sdn_port_map.keys(): if egr_port != of_port: break #egr_port = (i+1) %4 + 1 #print("\ncount: " + str(ing_port)) #print("erg_port : " + str(egr_port) + " ing_port: " + str(ing_port)) self.logger.info("\ncount: " + str(ing_port)) self.logger.info("erg_port : " + str(egr_port) + " ing_port: " + str(ing_port)) pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) request = testutils.flow_msg_create(self, pkt, ing_port = ing_port, egr_port = egr_port,check_expire=True) request.cookie = random.randint(0,9007199254740992) request.buffer_id = 0xffffffff request.hard_timeout = 1000 request.idle_timeout = 1000 rv = self.controller.message_send(request) self.assertTrue(rv != -1, "Error installing flow mod") testutils.do_barrier(self.controller) self.dataplane.send(ing_port, str(pkt)) (rcv_port, rcv_pkt, _) = self.dataplane.poll(timeout=1) #print("erg_port : " + str(rcv_port) + " pkt: %s" % str(rcv_pkt).encode("hex") ) #print("\n") self.logger.info("erg_port : " + str(rcv_port) + " pkt: %s" % str(rcv_pkt).encode("hex") ) self.logger.info("\n") self.assertTrue(rcv_pkt is not None, "Did not receive packet")
def runTest(self): # Config of_ports = ipv6_port_map.keys() of_ports.sort() ing_port = of_ports[0] egr_port = of_ports[2] table_id = testutils.WC_ACL_TABLE # Remove flows rc = testutils.delete_all_flows(self.controller, ipv6_logger) self.assertEqual(rc, 0, "Failed to delete all flows") # Add entry match pkt = testutils.simple_ipv6_packet(tcp_sport=80, tcp_dport=8080) request = testutils.flow_msg_create(self, pkt, ing_port = ing_port, egr_port = egr_port, table_id = table_id) testutils.flow_msg_install(self, request) #Send packet ipv6_logger.info("Sending IPv6 packet to " + str(ing_port)) ipv6_logger.debug("Data: " + str(pkt).encode('hex')) self.dataplane.send(ing_port, str(pkt)) #Receive packet exp_pkt = testutils.simple_ipv6_packet(tcp_sport=80, tcp_dport=8080) testutils.receive_pkt_verify(self, egr_port, exp_pkt) #Remove flows rc = testutils.delete_all_flows(self.controller, ipv6_logger) self.assertEqual(rc, 0, "Failed to delete all flows")
def runExpireTest(self, idle_timeout=0, hard_timeout=0): 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 = pa_config["base_of_port"] egress_port = (pa_config["base_of_port"] + 1) % len(of_ports) pa_logger.info("Ingress " + str(ingress_port) + " to egress " + str(egress_port)) # # match.in_port = ingress_port # # request = message.flow_mod() # request.match = match # request = testutils.flow_msg_create(self, pkt, ingress_port, egr_port=egress_port, check_expire=True) request.cookie = random.randint(0,9007199254740992) request.buffer_id = 0xffffffff request.idle_timeout = idle_timeout request.hard_timeout = hard_timeout request.flags |= ofp.OFPFF_SEND_FLOW_REM match = request.match pa_logger.info("Inserting flow") rv = self.controller.message_send(request) self.assertTrue(rv != -1, "Error installing flow mod") do_barrier(self.controller) (response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 2) self.assertTrue(response is not None, 'Did not receive flow removed message ') self.assertEqual(request.cookie, response.cookie, 'Cookies do not match') if idle_timeout == 0: self.assertEqual(ofp.OFPRR_HARD_TIMEOUT, response.reason, 'Flow table entry removal reason is not idle_timeout') elif hard_timeout == 0: self.assertEqual(ofp.OFPRR_IDLE_TIMEOUT, response.reason, 'Flow table entry removal reason is not idle_timeout') self.assertEqual(match, response.match, 'Flow table entry does not match')
def runTest(self): self.clear_switch() group_add_msg2 = \ create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 2, buckets = [ create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 2000), create_action(action = ofp.OFPAT_OUTPUT, port = 2) ]) ]) self.send_ctrl_exp_noerror(group_add_msg2, 'group add 2') group_add_msg3 = \ create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 3, buckets = [ create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 3000), create_action(action = ofp.OFPAT_OUTPUT, port = 3) ]), create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 4000), create_action(action = ofp.OFPAT_OUTPUT, port = 4) ]) ]) self.send_ctrl_exp_noerror(group_add_msg3, 'group add 3') group_add_msg1 = \ create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 1, buckets = [ create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_GROUP, group_id = 2), ]), create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_GROUP, group_id = 3), ]) ]) self.send_ctrl_exp_noerror(group_add_msg1, 'group add 1') packet_in = testutils.simple_tcp_packet(tcp_sport=1000) packet_out1 = testutils.simple_tcp_packet(tcp_sport=2000) packet_out2 = testutils.simple_tcp_packet(tcp_sport=3000) packet_out3 = testutils.simple_tcp_packet(tcp_sport=4000) flow_add_msg = \ testutils.flow_msg_create(self,packet_in,ing_port = 1,action_list = [ create_action(action = ofp.OFPAT_GROUP, group_id = 1) ]) self.send_ctrl_exp_noerror(flow_add_msg, 'flow add') self.send_data(packet_in, 1) self.recv_data(2, packet_out1) self.recv_data(3, packet_out2) self.recv_data(4, packet_out3)
def runTest(self): ing_port = flow_mods_port_map.keys()[0] out_port1 = flow_mods_port_map.keys()[1] out_port2 = flow_mods_port_map.keys()[2] pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) fm_orig = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port1) fm_new = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port2) fm_new.command = ofp.OFPFC_MODIFY_STRICT testutils.ofmsg_send(self, fm_orig) testutils.ofmsg_send(self, fm_new) flow_stats = testutils.flow_stats_get(self) self.assertEqual(len(flow_stats.stats),1, "Expected only one flow_mod") stat = flow_stats.stats[0] #self.assertEqual(stat.match_fields, fm_new.match_fields) self.assertEqual(stat.instructions, fm_new.instructions, "instructions not equal !")
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): testutils.clear_switch(self,group_port_map,group_logger) # self.clear_switch() group_add_msg = \ create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_SELECT, group_id = 1, buckets = [ create_bucket(1, 0, 0, [ create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 2000), create_action(action = ofp.OFPAT_OUTPUT, port = 2) ]), create_bucket(1, 0, 0, [ create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 3000), create_action(action = ofp.OFPAT_OUTPUT, port = 3) ]), create_bucket(1, 0, 0, [ create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 4000), create_action(action = ofp.OFPAT_OUTPUT, port = 4) ]) ]) self.send_ctrl_exp_noerror(group_add_msg, 'group add') packet_in = testutils.simple_tcp_packet(tcp_sport=1000) packet_out1 = testutils.simple_tcp_packet(tcp_sport=2000) packet_out2 = testutils.simple_tcp_packet(tcp_sport=3000) packet_out3 = testutils.simple_tcp_packet(tcp_sport=4000) flow_add_msg = \ testutils.flow_msg_create(self,packet_in,ing_port = 1,action_list = [ create_action(action = ofp.OFPAT_GROUP, group_id = 1) ]) self.send_ctrl_exp_noerror(flow_add_msg, 'flow add') self.send_data(packet_in, 1) recv1 = self.recv_data(2) recv2 = self.recv_data(3) recv3 = self.recv_data(4) self.assertTrue(((recv1 is not None) or (recv2 is not None) or (recv3 is not None)), "Did not receive a packet") self.assertTrue(((recv1 is not None) and (recv2 is None) and (recv3 is None)) or \ ((recv1 is None) and (recv2 is not None) and (recv3 is None)) or \ ((recv1 is None) and (recv2 is None) and (recv3 is not None)), "Received too many packets") self.assertTrue(((recv1 is not None) and testutils.pkt_verify(self, recv1, packet_out1)) or \ ((recv2 is not None) and testutils.pkt_verify(self, recv2, packet_out2)) or \ ((recv3 is not None) and testutils.pkt_verify(self, recv3, packet_out3)), "Received unexpected packet")
def runTest(self): ing_port = flow_mods_port_map.keys()[0] egr_port = flow_mods_port_map.keys()[1] table_id = testutils.EX_L3_TABLE flow_count = 10 testutils.delete_all_flows_one_table(self.controller, self.logger, table_id) match_fields_ls = [] ipv6_src_addr = 'fe80::2420:52ff:fe8f:5188' metadata_val = 0xaa22334455667788 for i in range(flow_count): match_fields_ls.append(match_list()) match_fields_ls[i].add(match.eth_type(testutils.IPV6_ETHERTYPE)) match_fields_ls[i].add(match.ipv6_src(ipaddr.IPv6Address(ipv6_src_addr))) ipv6_dst_addr = 'fe80::2420:52ff:fe8f:' + str(5190+i) match_fields_ls[i].add(match.ipv6_dst(ipaddr.IPv6Address(ipv6_dst_addr))) match_fields_ls[i].add(match.metadata(metadata_val)) request = testutils.flow_msg_create(self, None, ing_port=ing_port, match_fields = match_fields_ls[i], egr_port = egr_port, table_id = table_id) testutils.flow_msg_install(self, request, False) match_fields = match_list() match_fields.add(match.eth_type(testutils.IPV6_ETHERTYPE)) match_fields.add(match.ipv6_src(ipaddr.IPv6Address(ipv6_src_addr))) response = testutils.flow_stats_get(self, table_id = table_id) self.assertTrue(len(response.stats) == flow_count, 'Did not add all flows successfully! Get table entry num is %d' %len(response.stats)) request = testutils.flow_msg_create(self, None, None, ing_port, match_fields, table_id = table_id) request.command = ofp.OFPFC_DELETE testutils.flow_msg_install(self, request, False) response = testutils.flow_stats_get(self, table_id = table_id) self.assertTrue(len(response.stats) == 0, 'Switch did not del the flow entry! Current table entry num is %d' %len(response.stats))
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): ing_port = flow_mods_port_map.keys()[0] out_port1 = flow_mods_port_map.keys()[1] out_port2 = flow_mods_port_map.keys()[2] pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) fm_orig = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port1) fm_new = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port2) fm_new.command = ofp.OFPFC_MODIFY_STRICT testutils.ofmsg_send(self, fm_orig) testutils.ofmsg_send(self, fm_new) flow_stats = testutils.flow_stats_get(self) self.assertEqual(len(flow_stats.stats), 1, "Expected only one flow_mod") stat = flow_stats.stats[0] #self.assertEqual(stat.match_fields, fm_new.match_fields) self.assertEqual(stat.instructions, fm_new.instructions, "instructions not equal !")
def runExpireTest(self, idle_timeout=0, hard_timeout=0): 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() ingress_port = pa_config["base_of_port"] egress_port = (pa_config["base_of_port"] + 1) % len(of_ports) pa_logger.info("Ingress " + str(ingress_port) + " to egress " + str(egress_port)) request = testutils.flow_msg_create(self, pkt, ing_port=ingress_port, egr_port=egress_port, check_expire=True) request.cookie = random.randint(0, 9007199254740992) request.buffer_id = 0xffffffff request.idle_timeout = idle_timeout request.hard_timeout = hard_timeout request.flags |= ofp.OFPFF_SEND_FLOW_REM match_fields = request.match_fields pa_logger.info("Inserting flow") testutils.ofmsg_send(self, request) (response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 8) self.assertTrue(response is not None, 'Did not receive flow removed message ') self.assertEqual(request.cookie, response.cookie, 'Cookies do not match') if idle_timeout == 0: self.assertEqual( ofp.OFPRR_HARD_TIMEOUT, response.reason, 'Flow table entry removal reason is not idle_timeout') elif hard_timeout == 0: self.assertEqual( ofp.OFPRR_IDLE_TIMEOUT, response.reason, 'Flow table entry removal reason is not idle_timeout')
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): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 2, "Not enough ports for test") 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") act1 = action.action_output() act2 = action.action_output() for idx in range(len(of_ports)): rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") ingress_port = of_ports[idx] egress_port1 = of_ports[(idx + 1) % len(of_ports)] egress_port2 = of_ports[(idx + 2) % len(of_ports)] pa_logger.info("Ingress " + str(ingress_port) + " to egress " + str(egress_port1) + " and " + str(egress_port2)) match.in_port = ingress_port act1.port = egress_port1 act2.port = egress_port2 request = testutils.flow_msg_create(self, pkt, ingress_port, action_list=[act1, act2]) request.buffer_id = 0xffffffff pa_logger.info("Inserting flow") rv = self.controller.message_send(request) 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)) yes_ports = set([egress_port1, egress_port2]) no_ports = set(of_ports).difference(yes_ports) testutils.receive_pkt_check(self.dataplane, pkt, yes_ports, no_ports, self, pa_logger)
def runTest(self): # self.clear_switch() testutils.clear_switch(self,group_port_map,group_logger) group_add_msg = \ create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 10, buckets = [ create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 2000), create_action(action = ofp.OFPAT_OUTPUT, port = 2) ]), create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 3000), create_action(action = ofp.OFPAT_OUTPUT, port = 3) ]) ]) self.send_ctrl_exp_noerror(group_add_msg, 'group add') packet_in = testutils.simple_tcp_packet(tcp_sport=1000) flow_add_msg = \ testutils.flow_msg_create(self,packet_in,ing_port = 1,action_list = [ create_action(action = ofp.OFPAT_GROUP, group_id = 10) ]) self.send_ctrl_exp_noerror(flow_add_msg, 'flow add') self.send_data(packet_in, 1) self.send_data(packet_in, 1) self.send_data(packet_in, 1) group_stats_req = \ create_group_stats_req(10) response = \ self.send_ctrl_exp_reply(group_stats_req, ofp.OFPT_STATS_REPLY, 'group stat') exp_len = ofp.OFP_HEADER_BYTES + \ ofp.OFP_STATS_REPLY_BYTES + \ ofp.OFP_GROUP_STATS_BYTES + \ ofp.OFP_BUCKET_COUNTER_BYTES * 2 self.assertEqual(len(response), exp_len, 'Received packet length does not equal expected length')
def runTest(self): table_id = testutils.EX_L2_TABLE of_ports = exact_port_map.keys() egr_port = of_ports[1] pkt = testutils.simple_tcp_packet(dl_src='08:02:ff:34:88:99', dl_dst='22:22:ed:22:5f:1a') request = testutils.flow_msg_create(self, pkt, egr_port = egr_port, table_id = table_id) for obj in request.match_fields.tlvs: if obj.field == ofp.OFPXMT_OFB_METADATA: obj.value = 0x9922334455667788 request.idle_timeout = 1 request.flags |= ofp.OFPFF_SEND_FLOW_REM testutils.flow_msg_install(self, request) #print(request.show()) (response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 3) self.assertTrue(response is not None, 'Did not receive flow removed message ') self.assertEqual(request.cookie, response.cookie, 'Cookies do not match') self.assertEqual(ofp.OFPRR_IDLE_TIMEOUT, response.reason, 'Flow table entry removal reason is not idle_timeout')
def runExpireTest(self, idle_timeout=0, hard_timeout=0): 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() ingress_port = pa_config["base_of_port"] egress_port = (pa_config["base_of_port"] + 1) % len(of_ports) pa_logger.info("Ingress " + str(ingress_port) + " to egress " + str(egress_port)) request = testutils.flow_msg_create(self, pkt, ing_port=ingress_port, egr_port=egress_port, check_expire=True) request.cookie = random.randint(0,9007199254740992) request.buffer_id = 0xffffffff request.idle_timeout = idle_timeout request.hard_timeout = hard_timeout request.flags |= ofp.OFPFF_SEND_FLOW_REM match_fields = request.match_fields pa_logger.info("Inserting flow") testutils.ofmsg_send(self, request) (response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 8) self.assertTrue(response is not None, 'Did not receive flow removed message ') self.assertEqual(request.cookie, response.cookie, 'Cookies do not match') if idle_timeout == 0: self.assertEqual(ofp.OFPRR_HARD_TIMEOUT, response.reason, 'Flow table entry removal reason is not idle_timeout') elif hard_timeout == 0: self.assertEqual(ofp.OFPRR_IDLE_TIMEOUT, response.reason, 'Flow table entry removal reason is not idle_timeout')
def runTest(self): of_ports = testutils.clear_switch(self, exact_port_map.keys(), exact_logger)#zhaoxiuchu table_id = testutils.EX_L2_TABLE of_ports = exact_port_map.keys() egr_port = of_ports[1] pkt = testutils.simple_tcp_packet(dl_src='08:02:03:04:88:99', dl_dst='22:22:22:22:22:22') pkt_metadata = {'metadata_val':0xad22332e6f667588, 'metadata_msk':0xFFFFFFFFFFFFFFFF} request = testutils.flow_msg_create(self, pkt, pkt_metadata, egr_port = egr_port, table_id = table_id) request.hard_timeout = 1 request.flags |= ofp.OFPFF_SEND_FLOW_REM testutils.flow_msg_install(self, request) #print(request.show()) (response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 3) self.assertTrue(response is not None,'Did not receive flow removed message ') self.assertEqual(request.cookie, response.cookie,'Cookies do not match') self.assertEqual(ofp.OFPRR_HARD_TIMEOUT, response.reason, 'Flow table entry removal reason is not idle_timeout')
def runTest(self): """ ** Currently, same scenario with "NoGoto" ** Add four flow entries: First Table; Match IP Src A; goto Second Table Second Table; Match IP Src A; send to 1, goto Third Table Third Table; Match IP Src A; do nothing // match but stop pipeline Fourth Table; Match IP Src A; send to 2 // not match, just a fake Then send in 2 packets: IP A, TCP C; expect out port 1 IP A, TCP B; expect out port 1 """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up first match testutils.write_goto(self, testutils.WC_ACL_TABLE, testutils.WC_SERV_TABLE) # Set up second match testutils.write_goto_output(self, testutils.WC_SERV_TABLE, testutils.EX_L2_TABLE, of_ports[0], of_ports[2]) # Set up third match, "Empty Instruction" pkt = testutils.simple_tcp_packet() request = testutils.flow_msg_create(self, pkt, ing_port=of_ports[2], table_id=testutils.EX_L2_TABLE) testutils.flow_msg_install(self, request) # Set up fourth match testutils.write_output(self, testutils.EX_VLAN_TABLE, of_ports[1]) # Generate a packet matching flow 1, 2, and 3; rcv on port[0] testutils.reply_check_dp(self, tcp_sport=1234, ing_port=of_ports[2], egr_port=of_ports[0])
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 2, "Not enough ports for test") pkt = testutils.simple_tcp_packet() match_fields = testutils.packet_to_exact_flow_match(pkt) self.assertTrue(match_fields is not None, "Could not generate flow match from pkt") act1 = action.action_output() act2 = action.action_output() for idx in range(len(of_ports)): rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") ingress_port = of_ports[idx] egress_port1 = of_ports[(idx + 1) % len(of_ports)] egress_port2 = of_ports[(idx + 2) % len(of_ports)] pa_logger.info("Ingress " + str(ingress_port) + " to egress " + str(egress_port1) + " and " + str(egress_port2)) act1.port = egress_port1 act2.port = egress_port2 request = testutils.flow_msg_create( self, pkt, ing_port=ingress_port, action_list=[act1, act2], inst_app_flag=testutils.APPLY_ACTIONS_INSTRUCTION) pa_logger.info("Inserting flow") testutils.ofmsg_send(self, request) pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) yes_ports = set([egress_port1, egress_port2]) no_ports = set(of_ports).difference(yes_ports) testutils.receive_pkt_check(self.dataplane, pkt, yes_ports, no_ports, self, pa_logger)
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") 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() for ingress_port in of_ports: rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") pa_logger.info("Ingress " + str(ingress_port) + " to all ports") # match.in_port = ingress_port # # request = message.flow_mod() # request.match = match # request.buffer_id = 0xffffffff # act.port = ofp.OFPP_ALL # self.assertTrue(request.actions.add(act), # "Could not add ALL port action") request = testutils.flow_msg_create(self, pkt, ing_port=ingress_port, egr_port=ofp.OFPP_ALL) # already done in flow_msg_create #pa_logger.info(request.show()) pa_logger.info("Inserting flow") rv = self.controller.message_send(request) 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)) yes_ports = set(of_ports).difference([ingress_port]) testutils.receive_pkt_check(self.dataplane, pkt, yes_ports, [ingress_port], self, pa_logger)
def runTest(self): for of_port in sdn_port_map.keys(): ing_port = of_port for egr_port in sdn_port_map.keys(): if egr_port != of_port: break #egr_port = (i+1) %4 + 1 #print("\ncount: " + str(ing_port)) #print("erg_port : " + str(egr_port) + " ing_port: " + str(ing_port)) self.logger.info("\ncount: " + str(ing_port)) self.logger.info("erg_port : " + str(egr_port) + " ing_port: " + str(ing_port)) pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) request = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=egr_port, check_expire=True) request.cookie = random.randint(0, 9007199254740992) request.buffer_id = 0xffffffff request.hard_timeout = 1000 request.idle_timeout = 1000 rv = self.controller.message_send(request) self.assertTrue(rv != -1, "Error installing flow mod") testutils.do_barrier(self.controller) self.dataplane.send(ing_port, str(pkt)) (rcv_port, rcv_pkt, _) = self.dataplane.poll(timeout=1) #print("erg_port : " + str(rcv_port) + " pkt: %s" % str(rcv_pkt).encode("hex") ) #print("\n") self.logger.info("erg_port : " + str(rcv_port) + " pkt: %s" % str(rcv_pkt).encode("hex")) self.logger.info("\n") self.assertTrue(rcv_pkt is not None, "Did not receive packet")
def flow_match_test_port_pair_mpls_two_tables( parent, ing_port, egr_port, wildcards=0, mpls_type=ETHERTYPE_MPLS, mpls_label=-1, mpls_tc=0, mpls_ttl=64, mpls_label_int=-1, mpls_tc_int=0, mpls_ttl_int=32, ip_ttl=192, label_match_tbl0=0, tc_match_tbl0=0, dl_type_match_tbl0=ETHERTYPE_MPLS, action_list_tbl0=None, check_expire_tbl0=False, match_exp_tbl0=True, exp_msg_tbl0=ofp.OFPT_FLOW_REMOVED, exp_msg_type_tbl0=0, exp_msg_code_tbl0=0, label_match_tbl1=0, tc_match_tbl1=0, dl_type_match_tbl1=ETHERTYPE_MPLS, check_expire_tbl1=False, match_exp_tbl1=True, exp_msg_tbl1=ofp.OFPT_FLOW_REMOVED, exp_msg_type_tbl1=0, exp_msg_code_tbl1=0, add_tag_exp=False, exp_mpls_type=ETHERTYPE_MPLS, exp_mpls_label=-1, exp_mpls_tc=0, exp_mpls_ttl=64, exp_mpls_ttl_int=32, exp_ip_ttl=192, pkt=None, exp_pkt=None): """ Flow match test for various mpls matching patterns on single TCP packet Run test with packet through switch from ing_port to egr_port See flow_match_test for parameter descriptions """ parent.logger.info("Pkt match test: " + str(ing_port) + " to " + str(egr_port)) parent.logger.debug(" WC: " + hex(wildcards) + " mpls label: " + str(mpls_label) + " mpls tc: " + str(mpls_tc) + " expire_table0: " + str(check_expire_tbl0) + " expire_table1: " + str(check_expire_tbl1)) # Check if the switch supports all the MPLS actions sup_act_dic = mplsact.mpls_action_support_check(parent) sup_act_elm = sup_act_dic.keys() for i in sup_act_elm: if sup_act_dic[i] == False: testutils.skip_message_emit( parent, "Switch doesn't support " + "one or more of MPLS actions : " + i) return len = 100 len_w_shim = len + 4 len_w_2shim = len_w_shim + 4 len_w_3shim = len_w_2shim + 4 if pkt is None: if mpls_label >= 0: if mpls_label_int >= 0: pktlen = len_w_2shim else: pktlen = len_w_shim else: pktlen = len pkt = testutils.simple_tcp_packet_w_mpls(pktlen=pktlen, mpls_type=mpls_type, mpls_label=mpls_label, mpls_tc=mpls_tc, mpls_ttl=mpls_ttl, mpls_label_int=mpls_label_int, mpls_tc_int=mpls_tc_int, mpls_ttl_int=mpls_ttl_int, ip_ttl=ip_ttl) if exp_pkt is None: if exp_mpls_label >= 0: if add_tag_exp: if mpls_label_int >= 0: exp_pktlen = len_w_3shim else: exp_pktlen = len_w_2shim else: if mpls_label_int >= 0: exp_pktlen = len_w_2shim else: exp_pktlen = len_w_shim else: #subtract action if mpls_label_int >= 0: exp_pktlen = len_w_shim else: exp_pktlen = len if add_tag_exp: exp_pkt = testutils.simple_tcp_packet_w_mpls( pktlen=exp_pktlen, mpls_type=exp_mpls_type, mpls_label_ext=exp_mpls_label, mpls_tc_ext=exp_mpls_tc, mpls_ttl_ext=exp_mpls_ttl, mpls_label=mpls_label, mpls_tc=mpls_tc, mpls_ttl=mpls_ttl, mpls_label_int=mpls_label_int, mpls_tc_int=mpls_tc_int, mpls_ttl_int=exp_mpls_ttl_int, ip_ttl=exp_ip_ttl) else: if (exp_mpls_label < 0) and (mpls_label_int >= 0): exp_pkt = testutils.simple_tcp_packet_w_mpls( pktlen=exp_pktlen, mpls_type=mpls_type, mpls_label=mpls_label_int, mpls_tc=mpls_tc_int, mpls_ttl=exp_mpls_ttl_int, ip_ttl=exp_ip_ttl) else: exp_pkt = testutils.simple_tcp_packet_w_mpls( pktlen=exp_pktlen, mpls_type=exp_mpls_type, mpls_label=exp_mpls_label, mpls_tc=exp_mpls_tc, mpls_ttl=exp_mpls_ttl, mpls_label_int=mpls_label_int, mpls_tc_int=mpls_tc_int, mpls_ttl_int=exp_mpls_ttl_int, ip_ttl=exp_ip_ttl) # Flow Mod for Table0 match = parse.packet_to_flow_match(pkt) parent.assertTrue(match is not None, "Flow match from pkt failed") match.mpls_label = label_match_tbl0 match.mpls_tc = tc_match_tbl0 match.dl_type = dl_type_match_tbl0 if ((dl_type_match_tbl0 == ETHERTYPE_MPLS) or (dl_type_match_tbl0 == ETHERTYPE_MPLS_MC)): match.nw_tos = 0 match.nw_proto = 0 match.nw_src = 0 match.nw_src_mask = 0 match.nw_dst = 0 match.nw_dst_mask = 0 match.tp_src = 0 match.tp_dst = 0 inst_1 = instruction.instruction_apply_actions() inst_2 = instruction.instruction_goto_table() inst_2.table_id = 1 inst_list = [inst_1, inst_2] request0 = testutils.flow_msg_create(parent, pkt, ing_port=ing_port, instruction_list=inst_list, action_list=action_list_tbl0, wildcards=wildcards, match=match, check_expire=check_expire_tbl0, table_id=0) testutils.flow_msg_install(parent, request0) # Flow Mod for Table1 match = parse.packet_to_flow_match(exp_pkt) parent.assertTrue(match is not None, "Flow match from pkt failed") match.mpls_label = label_match_tbl1 match.mpls_tc = tc_match_tbl1 match.dl_type = dl_type_match_tbl1 if ((dl_type_match_tbl1 == ETHERTYPE_MPLS) or (dl_type_match_tbl1 == ETHERTYPE_MPLS_MC)): match.nw_tos = 0 match.nw_proto = 0 match.nw_src = 0 match.nw_src_mask = 0 match.nw_dst = 0 match.nw_dst_mask = 0 match.tp_src = 0 match.tp_dst = 0 request1 = testutils.flow_msg_create(parent, pkt, ing_port=ing_port, wildcards=wildcards, match=match, check_expire=check_expire_tbl1, table_id=1, egr_port=egr_port) testutils.flow_msg_install(parent, request1) parent.logger.debug("Send packet: " + str(ing_port) + " to " + str(egr_port)) parent.dataplane.send(ing_port, str(pkt)) # Check response from switch #@todo Not all HW supports both pkt and byte counters #@todo We shouldn't expect the order of coming response.. if match_exp_tbl0: if check_expire_tbl0: flow_removed_verify(parent, request0, pkt_count=1, byte_count=pktlen) else: if exp_msg_tbl0 is ofp.OFPT_FLOW_REMOVED: if check_expire_tbl0: flow_removed_verify(parent, request0, pkt_count=0, byte_count=0) elif exp_msg_tbl0 is ofp.OFPT_ERROR: error_verify(parent, exp_msg_type_tbl0, exp_msg_code_tbl0) else: parent.assertTrue(0, "Rcv: Unexpected Message: " + str(exp_msg_tbl0)) if match_exp_tbl1: if check_expire_tbl1: flow_removed_verify(parent, request1, pkt_count=1, byte_count=exp_pktlen) else: if exp_msg_tbl1 is ofp.OFPT_FLOW_REMOVED: if check_expire_tbl1: flow_removed_verify(parent, request1, pkt_count=0, byte_count=0) elif exp_msg_tbl1 is ofp.OFPT_ERROR: error_verify(parent, exp_msg_type_tbl1, exp_msg_code_tbl1) else: parent.assertTrue(0, "Rcv: Unexpected Message: " + str(exp_msg_tbl1)) # Check pkt if match_exp_tbl0 and match_exp_tbl1: testutils.receive_pkt_verify(parent, egr_port, exp_pkt) else: (_, rcv_pkt, _) = parent.dataplane.poll(timeout=1) parent.assertFalse(rcv_pkt is not None, "Packet on dataplane")
def write_action_test_multi_tables(parent, ing_port, egr_port, match = None, wildcards = 0, act_list = None, next_avail = None, chk_expire = None, pkt = None, exp_pkt = None): """ Testing framework for write_action tests with multiple tables @param parent Must implement controller, dataplane, assertTrue, assertEqual and logger @param ing_port Ingress OF port @param egr_port Egress OF port @match Match field in flow_mod commans for all the tables @param wildcard Match.wildcard filed in flow_mod commands for all the tables @param act_list Array of action list for each table @param next_avail Array. Indicate False for no more tables are used @param chk_expire Array. Indicate True if you want flow_removed msg @param pkt Pkt to be sent @param exp_pkt Expected pkt """ parent.assertTrue(match is not None, "Match param doesn't exist") parent.assertTrue(act_list is not None, "act_list param doesn't exist") parent.assertTrue(next_avail is not None, "next_avail param doesn't exist") parent.assertTrue(chk_expire is not None, "chk_expire param doesn't exist") wildcards = wildcards & 0xfffffffff # mask out anything out of range request_list = [] for table_id in range(MAX_TABLE): inst_list = [] inst = instruction.instruction_write_actions() inst_list.append(inst) action_list = act_list[table_id] check_expire = chk_expire[table_id] if next_avail[table_id]: inst = instruction.instruction_goto_table() inst.table_id = table_id + 1 inst_list.append(inst) else: pass request = testutils.flow_msg_create(parent, pkt, ing_port=ing_port, instruction_list=inst_list, action_list=action_list, wildcards=wildcards, match=match, check_expire=check_expire, table_id=table_id) request_list.append(request) testutils.flow_msg_install(parent, request_list[table_id]) if next_avail[table_id]: pass else: num_table_used = table_id + 1 break parent.logger.debug("Send packet: " + str(ing_port) + " to " + str(egr_port)) parent.dataplane.send(ing_port, str(pkt)) # Check response from switch #@todo Not all HW supports both pkt and byte counters #@todo We shouldn't expect the order of coming response.. for table_id in range(num_table_used): if chk_expire[table_id]: flow_removed_verify(parent, request_list[table_id], pkt_count=1, byte_count=pktlen) testutils.receive_pkt_verify(parent, egr_port, exp_pkt)