def runTest(self): of_ports = testutils.clear_switch(self, exact_port_map.keys(), exact_logger)#zhaoxiuchu vlan_tags=[{'type': 0x8100, 'vid': 3, 'pcp': 1}] mpls_tags=[{'type': 0x8847, 'label': 22, 'tc': 2, 'ttl': 48}] ing_port = 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(dl_src='00:01:02:03:04:05', dl_dst='00:06:07:08:09:0a', \ vlan_tags = vlan_tags, mpls_tags = mpls_tags) 'table 0 goto table3' match_ls = testutils.packet_to_exact_flow_match(pkt = pkt, table_id = testutils.EX_ACL_TABLE, ing_port = ing_port) exact_table_goto_table(self, testutils.EX_ACL_TABLE, testutils.EX_L2_TABLE, match_ls) "set table 3 not match, continue" testutils.set_table_config(self, testutils.EX_L2_TABLE, ofp.OFPTC_TABLE_MISS_CONTROLLER, True) 'table 4 output' match_ls = testutils.packet_to_exact_flow_match(pkt = pkt, table_id = testutils.EX_VLAN_TABLE, ing_port = ing_port) exact_table_output(self, testutils.EX_VLAN_TABLE, match_ls, egr_port = egr_port) "send a packet from ing_port " self.dataplane.send(ing_port, str(pkt)) # checks no response from controller and dataplane (response, _) = self.controller.poll(ofp.OFPT_PACKET_IN, 2) # self.assertIsNone() is preferable for newer python self.assertTrue(response is not None, "PacketIn message is not received") (_, rcv_pkt, _) = self.dataplane.poll(timeout=5) self.assertFalse(rcv_pkt is not None, "Packet on dataplane")
def runTest(self): vlan_tags = [{'type': 0x8100, 'vid': 3, 'pcp': 1}] mpls_tags = [{'type': 0x8847, 'label': 22, 'tc': 2, 'ttl': 48}] ing_port = 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(dl_src='00:01:02:03:04:05', dl_dst='00:06:07:08:09:0a', \ vlan_tags = vlan_tags, mpls_tags = mpls_tags) 'table 0 goto table3' match_ls = testutils.packet_to_exact_flow_match( pkt=pkt, table_id=testutils.EX_ACL_TABLE, ing_port=ing_port) exact_table_goto_table(self, testutils.EX_ACL_TABLE, testutils.EX_L2_TABLE, match_ls) "set table 3 not match, continue" testutils.set_table_config(self, testutils.EX_L2_TABLE, ofp.OFPTC_TABLE_MISS_CONTINUE, True) 'table 4 output' match_ls = testutils.packet_to_exact_flow_match( pkt=pkt, table_id=testutils.EX_VLAN_TABLE, ing_port=ing_port) exact_table_output(self, testutils.EX_VLAN_TABLE, match_ls, egr_port=egr_port) "send a packet from ing_port " self.dataplane.send(ing_port, str(pkt)) 'verify the rec data' testutils.receive_pkt_verify(self, egr_port, pkt)
def runTest(self): 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 test packet;" pkt = testutils.simple_tcp_packet(dl_src='00:01:02:03:04:05', dl_dst='00:06:07:08:09:0a') match_ls = testutils.packet_to_exact_flow_match( pkt=pkt, table_id=testutils.EX_ACL_TABLE, ing_port=port_in) exact_table_goto_table(self, testutils.EX_ACL_TABLE, testutils.EX_L2_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match( pkt=pkt, table_id=testutils.EX_L2_TABLE, ing_port=port_in) exact_table_output(self, testutils.EX_L2_TABLE, match_ls, egr_port=egr_port) testutils.do_barrier(self.controller) "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) #print( str(pkt_rec).encode('hex')) self.assertTrue(pkt_rec is not None, "rec none packets") self.assertEqual(str(pkt), str(pkt_rec), 'retruned pkt not equal to the original pkt')
def runTest(self): vlan_tags = [{'type': 0x8100, 'vid': 3, 'pcp': 1}] mpls_tags = [{'type': 0x8847, 'label': 22, 'tc': 2, 'ttl': 48}] ing_port = 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(dl_src='00:01:02:03:04:05', dl_dst='00:06:07:08:09:0a', \ vlan_tags = vlan_tags, mpls_tags = mpls_tags) 'table 0 goto table3' match_ls = testutils.packet_to_exact_flow_match( pkt=pkt, table_id=testutils.EX_ACL_TABLE, ing_port=ing_port) exact_table_goto_table(self, testutils.EX_ACL_TABLE, testutils.EX_L2_TABLE, match_ls) "set table 3 not match, continue" testutils.set_table_config(self, testutils.EX_L2_TABLE, ofp.OFPTC_TABLE_MISS_DROP, True) 'table 4 output' match_ls = testutils.packet_to_exact_flow_match( pkt, None, testutils.EX_VLAN_TABLE, ing_port) exact_table_output(self, testutils.EX_VLAN_TABLE, match_ls, egr_port=egr_port) "send a packet from ing_port " self.dataplane.send(ing_port, str(pkt)) # checks no response from controller and dataplane (response, _) = self.controller.poll(ofp.OFPT_PACKET_IN, 2) # self.assertIsNone() is preferable for newer python self.assertFalse(response is not None, "PacketIn message is received") (_, rcv_pkt, _) = self.dataplane.poll(timeout=5) self.assertFalse(rcv_pkt is not None, "Packet on dataplane")
def runTest(self): vlan_tags = [{'type': 0x8100, 'vid': 3, 'pcp': 1}] mpls_tags = [{'type': 0x8847, 'label': 22, 'tc': 2, 'ttl': 48}] ing_port = exact_port_map.keys()[0] egr_port = exact_port_map.keys()[1] #"clear swtich;" testutils.delete_all_flows(self.controller, self.logger) "make test packet;" pkt = testutils.simple_tcp_packet(vlan_tags=vlan_tags, mpls_tags=mpls_tags) match_ls = testutils.packet_to_exact_flow_match( pkt=pkt, table_id=testutils.EX_ACL_TABLE, ing_port=ing_port) exact_table_goto_table(self, testutils.EX_ACL_TABLE, testutils.EX_L2_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match( pkt=pkt, table_id=testutils.EX_L2_TABLE, ing_port=ing_port) exact_table_goto_table(self, testutils.EX_L2_TABLE, testutils.EX_VLAN_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match( pkt=pkt, table_id=testutils.EX_VLAN_TABLE, ing_port=ing_port) exact_table_goto_table(self, testutils.EX_VLAN_TABLE, testutils.EX_MPLS_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match( pkt=pkt, table_id=testutils.EX_MPLS_TABLE, ing_port=ing_port) exact_table_goto_table(self, testutils.EX_MPLS_TABLE, testutils.EX_L3_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match( pkt=pkt, table_id=testutils.EX_L3_TABLE, ing_port=ing_port) exact_table_output(self, testutils.EX_L3_TABLE, match_ls, egr_port=egr_port) testutils.do_barrier(self.controller) "send a packet from ing_port " self.dataplane.send(ing_port, 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 packets") #print("++++++++++++++++++++++rcv_pkt++++++++++++++++++++++") #if pkt_rec is None: # print(str(pkt_rec)) #else: # print(str(pkt_rec).encode('hex')) self.assertEqual(str(pkt), str(pkt_rec), 'retruned pkt not equal to the original pkt')
def runTest(self): vlan_tags=[{'type': 0x8100, 'vid': 1, 'pcp': 1}] #mpls_tags=[{'type': 0x8847, 'label': 22, 'tc': 2, 'ttl': 48}] pkt = testutils.simple_icmp_packet( dl_dst='00:01:02:03:04:05', dl_src='00:06:07:08:09:0a', vlan_tags=vlan_tags, mpls_tags=[], ip_src='192.168.0.55', ip_dst='192.168.3.254', ip_tos=5, ip_ttl=47, icmp_type=8, icmp_code=0, payload_len=100) of_ports = exact_port_map.keys() for dp_port1 in of_ports: ing_port = dp_port1 for dp_port2 in of_ports: if dp_port2 != dp_port1: egr_port = dp_port2 #match_ls = testutils.packet_to_exact_flow_match(pkt, None, testutils.EX_ACL_TABLE, ing_port) #exact_table_goto_table(self, testutils.EX_ACL_TABLE, testutils.WC_ACL_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match(pkt, None, testutils.WC_ACL_TABLE, ing_port) exact_table_goto_table(self, testutils.WC_ACL_TABLE, testutils.WC_SERV_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match(pkt, None, testutils.WC_SERV_TABLE, ing_port) exact_table_goto_table(self, testutils.WC_SERV_TABLE, testutils.EX_L2_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match(pkt, None, testutils.EX_L2_TABLE, ing_port) exact_table_goto_table(self, testutils.EX_L2_TABLE, testutils.EX_VLAN_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match(pkt, None, testutils.EX_VLAN_TABLE, ing_port) exact_table_goto_table(self, testutils.EX_VLAN_TABLE, testutils.EX_MPLS_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match(pkt, None, testutils.EX_MPLS_TABLE, ing_port) exact_table_goto_table(self, testutils.EX_MPLS_TABLE, testutils.EX_L3_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match(pkt, None, testutils.EX_L3_TABLE, ing_port) exact_table_goto_table(self, testutils.EX_L3_TABLE, testutils.WC_L3_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match(pkt, None, testutils.WC_L3_TABLE, ing_port) exact_table_goto_table(self, testutils.WC_L3_TABLE, testutils.EX_ICMP_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match(pkt, None, testutils.EX_ICMP_TABLE, ing_port) exact_table_goto_table(self, testutils.EX_ICMP_TABLE, testutils.WC_ALL_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match(pkt, None, testutils.WC_ALL_TABLE, ing_port) exact_table_output(self, testutils.WC_ALL_TABLE, match_ls, egr_port = egr_port) self.dataplane.send(ing_port, str(pkt)) testutils.receive_pkt_verify(self, egr_port, pkt)
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 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(dl_src='00:01:02:03:04:05', dl_dst='00:06:07:08:09:0a') exp_pkt = testutils.simple_tcp_packet(dl_src='00:01:02:03:04:05', dl_dst='aa:aa:aa:aa:aa:aa') # get match list match_ls = testutils.packet_to_exact_flow_match(pkt = pkt, table_id = table_id, ing_port = port_in) act = action.action_set_field() field = match.eth_dst(parse.parse_mac("aa:aa:aa:aa:aa:aa")) act.field.add(field) exact_table_output(self, table_id, match_ls, actions = [act], egr_port = egr_port) testutils.do_barrier(self.controller) "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 is not None,"rec none packets") self.assertEqual(str(exp_pkt), str(pkt_rec), 'retruned pkt not equal to the original pkt')
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 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): 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): of_ports = pa_port_map.keys() ing_port = of_ports[1] egr_port = of_ports[2] "clear swtich;" testutils.delete_all_flows(self.controller, self.logger) # Set table config as "continue" testutils.set_table_config(self, testutils.EX_ACL_TABLE, ofp.OFPTC_TABLE_MISS_CONTINUE, True) testutils.set_table_config(self, testutils.WC_ACL_TABLE, ofp.OFPTC_TABLE_MISS_CONTINUE, True) testutils.set_table_config(self, testutils.WC_SERV_TABLE, ofp.OFPTC_TABLE_MISS_CONTROLLER, True) testutils.set_table_config(self, testutils.EX_L2_TABLE, ofp.OFPTC_TABLE_MISS_CONTINUE, True) testutils.set_table_config(self, testutils.EX_VLAN_TABLE, ofp.OFPTC_TABLE_MISS_CONTINUE, True) testutils.set_table_config(self, testutils.EX_MPLS_TABLE, ofp.OFPTC_TABLE_MISS_CONTINUE, True) testutils.set_table_config(self, testutils.EX_L3_TABLE, ofp.OFPTC_TABLE_MISS_CONTROLLER, True) #"make test packet;" pkt = testutils.simple_icmp_packet() inst_write_metadata = instruction.instruction_write_metadata(); inst_write_metadata.metadata = 0x20000000 inst_write_metadata.metadata_mask = 0xf0000000 testutils.write_goto(self, testutils.WC_SERV_TABLE, testutils.EX_L2_TABLE, ing_port, add_inst = inst_write_metadata) pkt_metadata = {'metadata_val':inst_write_metadata.metadata, 'metadata_msk':inst_write_metadata.metadata_mask} match_fields = testutils.packet_to_exact_flow_match(pkt_metadata = pkt_metadata, table_id = testutils.EX_L3_TABLE) testutils.write_output(self, testutils.EX_L3_TABLE, egr_port, match_fields=match_fields) testutils.reply_check_dp(self, tcp_sport=1234, ing_port = ing_port, egr_port = egr_port) testutils.set_table_config(self, testutils.EX_L3_TABLE, ofp.OFPTC_TABLE_MISS_CONTROLLER)
def runTest(self): of_ports = pa_port_map.keys() ing_port = of_ports[1] egr_port =ofp.OFPP_CONTROLLER "clear swtich;" testutils.delete_all_flows(self.controller, self.logger) # Set table config as "continue" testutils.set_table_config(self, testutils.WC_ACL_TABLE, ofp.OFPTC_TABLE_MISS_CONTINUE, True) testutils.set_table_config(self, testutils.WC_SERV_TABLE, ofp.OFPTC_TABLE_MISS_DROP, True) testutils.set_table_config(self, testutils.EX_L2_TABLE, ofp.OFPTC_TABLE_MISS_CONTROLLER, True) #"make test packet;" pkt = testutils.simple_icmp_packet() inst_write_metadata = instruction.instruction_write_metadata(); inst_write_metadata.metadata = 0x20000000 inst_write_metadata.metadata_mask = 0xf0000000 testutils.write_goto(self, testutils.WC_SERV_TABLE, testutils.EX_L2_TABLE, ing_port, add_inst = inst_write_metadata) pkt_metadata = {'metadata_val':inst_write_metadata.metadata, 'metadata_msk':inst_write_metadata.metadata_mask} match_fields = testutils.packet_to_exact_flow_match(pkt_metadata = pkt_metadata, table_id = testutils.EX_L2_TABLE) testutils.write_output(self, testutils.EX_L2_TABLE, egr_port, match_fields=match_fields) self.dataplane.send(ing_port, str(pkt)) (response, _) = self.controller.poll(ofp.OFPT_PACKET_IN, 2) self.assertTrue(response is not None, 'Packet in message not received on port ' + str(egr_port)) if str(pkt) != response.data: pa_logger.debug("pkt len " + str(len(str(pkt))) +": " + str(pkt)) pa_logger.debug("resp len " + str(len(str(response.data))) + ": " + str(response.data))
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): """ Add four flow entries: First Table; Match IP Src A; send to 1, goto Second Table Second Table; Match IP Src A; write metadata, goto Third Table Third Table; Match IP Src A and metadata; send to 2 // stop, do action Fourth Table; Match IP Src A; send to 1 // not match, just a trap Then send in 2 packets: IP A, TCP C; expect out port 2 IP A, TCP B; expect out port 2 @param self object instance @param EX_ACL_TABLE first table @param WC_ACL_TABLE second table @param WC_SERV_TABLE third table @param EX_VLAN_TABLE fourth table """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up first match testutils.write_goto_output(self, testutils.WC_ACL_TABLE, testutils.WC_SERV_TABLE, of_ports[0]) # Set up second match inst = instruction.instruction_write_metadata() inst.metadata = 0xfedcba9876543210 inst.metadata_mask = 0xffffffffffffffff testutils.write_goto(self, testutils.WC_SERV_TABLE, testutils.EX_L2_TABLE, of_ports[2], add_inst=inst) # Set up third match pkt_metadata = { 'metadata_val': inst.metadata, 'metadata_msk': inst.metadata_mask } match_fields = testutils.packet_to_exact_flow_match( pkt_metadata=pkt_metadata, table_id=testutils.EX_L2_TABLE) testutils.write_output(self, testutils.EX_L2_TABLE, of_ports[1], match_fields=match_fields) # Set up fourth match #write_output(self, testutils.EX_VLAN_TABLE, of_ports[0]) # Generate a packet matching flow 1, 2, and 3; rcv on port[1] testutils.reply_check_dp(self, tcp_sport=1234, ing_port=of_ports[2], egr_port=of_ports[1])
def runTest(self): of_ports = pa_port_map.keys() ing_port = of_ports[1] egr_port = of_ports[2] "clear swtich;" testutils.delete_all_flows(self.controller, self.logger) # Set table config as "continue" testutils.set_table_config(self, testutils.EX_ACL_TABLE, ofp.OFPTC_TABLE_MISS_CONTINUE, True) testutils.set_table_config(self, testutils.WC_ACL_TABLE, ofp.OFPTC_TABLE_MISS_CONTINUE, True) testutils.set_table_config(self, testutils.WC_SERV_TABLE, ofp.OFPTC_TABLE_MISS_CONTROLLER, True) testutils.set_table_config(self, testutils.EX_L2_TABLE, ofp.OFPTC_TABLE_MISS_CONTINUE, True) testutils.set_table_config(self, testutils.EX_VLAN_TABLE, ofp.OFPTC_TABLE_MISS_CONTINUE, True) testutils.set_table_config(self, testutils.EX_MPLS_TABLE, ofp.OFPTC_TABLE_MISS_CONTINUE, True) testutils.set_table_config(self, testutils.EX_L3_TABLE, ofp.OFPTC_TABLE_MISS_CONTROLLER, True) #"make test packet;" pkt = testutils.simple_icmp_packet() inst_write_metadata = instruction.instruction_write_metadata() inst_write_metadata.metadata = 0x20000000 inst_write_metadata.metadata_mask = 0xf0000000 testutils.write_goto(self, testutils.WC_SERV_TABLE, testutils.EX_L2_TABLE, ing_port, add_inst=inst_write_metadata) pkt_metadata = { 'metadata_val': inst_write_metadata.metadata, 'metadata_msk': inst_write_metadata.metadata_mask } match_fields = testutils.packet_to_exact_flow_match( pkt_metadata=pkt_metadata, table_id=testutils.EX_L3_TABLE) testutils.write_output(self, testutils.EX_L3_TABLE, egr_port, match_fields=match_fields) testutils.reply_check_dp(self, tcp_sport=1234, ing_port=ing_port, egr_port=egr_port) testutils.set_table_config(self, testutils.EX_L3_TABLE, ofp.OFPTC_TABLE_MISS_CONTROLLER)
def runTest(self): vlan_tags=[{'type': 0x8100, 'vid': 3, 'pcp': 1}] mpls_tags=[{'type': 0x8847, 'label': 22, 'tc': 2, 'ttl': 48}] ing_port = exact_port_map.keys()[0] egr_port = exact_port_map.keys()[1] #"clear swtich;" testutils.delete_all_flows(self.controller, self.logger) "make test packet;" pkt = testutils.simple_tcp_packet(vlan_tags = vlan_tags, mpls_tags = mpls_tags) match_ls = testutils.packet_to_exact_flow_match(pkt = pkt, table_id = testutils.EX_ACL_TABLE, ing_port = ing_port) exact_table_goto_table(self, testutils.EX_ACL_TABLE, testutils.EX_L2_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match(pkt = pkt, table_id = testutils.EX_L2_TABLE, ing_port = ing_port) exact_table_goto_table(self, testutils.EX_L2_TABLE, testutils.EX_VLAN_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match(pkt = pkt, table_id = testutils.EX_VLAN_TABLE, ing_port = ing_port) exact_table_goto_table(self, testutils.EX_VLAN_TABLE, testutils.EX_MPLS_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match(pkt = pkt, table_id = testutils.EX_MPLS_TABLE, ing_port = ing_port) exact_table_goto_table(self, testutils.EX_MPLS_TABLE, testutils.EX_L3_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match(pkt = pkt, table_id = testutils.EX_L3_TABLE, ing_port = ing_port) exact_table_output(self, testutils.EX_L3_TABLE, match_ls, egr_port = egr_port) testutils.do_barrier(self.controller) "send a packet from ing_port " self.dataplane.send(ing_port, 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 packets") #print("++++++++++++++++++++++rcv_pkt++++++++++++++++++++++") #if pkt_rec is None: # print(str(pkt_rec)) #else: # print(str(pkt_rec).encode('hex')) self.assertEqual(str(pkt), str(pkt_rec), 'retruned pkt not equal to the original pkt')
def runTest(self): 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 test packet;" pkt = testutils.simple_tcp_packet(dl_src='00:01:02:03:04:05', dl_dst='00:06:07:08:09:0a') match_ls = testutils.packet_to_exact_flow_match(pkt = pkt, table_id = testutils.EX_ACL_TABLE, ing_port = port_in) exact_table_goto_table(self, testutils.EX_ACL_TABLE, testutils.EX_L2_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match(pkt = pkt, table_id = testutils.EX_L2_TABLE, ing_port = port_in) exact_table_output(self, testutils.EX_L2_TABLE, match_ls, egr_port = egr_port) testutils.do_barrier(self.controller) "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) #print( str(pkt_rec).encode('hex')) self.assertTrue(pkt_rec is not None,"rec none packets") self.assertEqual(str(pkt), str(pkt_rec), 'retruned pkt not equal to the original pkt')
def runTest(self): vlan_tags=[{'type': 0x8100, 'vid': 3, 'pcp': 1}] mpls_tags=[{'type': 0x8847, 'label': 22, 'tc': 2, 'ttl': 48}] ing_port = 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(dl_src='00:01:02:03:04:05', dl_dst='00:06:07:08:09:0a', \ vlan_tags = vlan_tags, mpls_tags = mpls_tags) 'table 0 goto table3' match_ls = testutils.packet_to_exact_flow_match(pkt = pkt, table_id = testutils.EX_ACL_TABLE, ing_port = ing_port) exact_table_goto_table(self, testutils.EX_ACL_TABLE, testutils.EX_L2_TABLE, match_ls) "set table 3 not match, continue" testutils.set_table_config(self, testutils.EX_L2_TABLE, ofp.OFPTC_TABLE_MISS_CONTINUE, True) 'table 4 output' match_ls = testutils.packet_to_exact_flow_match(pkt = pkt, table_id = testutils.EX_VLAN_TABLE, ing_port = ing_port) exact_table_output(self, testutils.EX_VLAN_TABLE, match_ls, egr_port = egr_port) "send a packet from ing_port " self.dataplane.send(ing_port, str(pkt)) 'verify the rec data' testutils.receive_pkt_verify(self, egr_port, pkt)
def runTest(self): of_ports = pa_port_map.keys() ing_port = of_ports[1] egr_port = ofp.OFPP_CONTROLLER "clear swtich;" testutils.delete_all_flows(self.controller, self.logger) # Set table config as "continue" testutils.set_table_config(self, testutils.WC_ACL_TABLE, ofp.OFPTC_TABLE_MISS_CONTINUE, True) testutils.set_table_config(self, testutils.WC_SERV_TABLE, ofp.OFPTC_TABLE_MISS_DROP, True) testutils.set_table_config(self, testutils.EX_L2_TABLE, ofp.OFPTC_TABLE_MISS_CONTROLLER, True) #"make test packet;" pkt = testutils.simple_icmp_packet() inst_write_metadata = instruction.instruction_write_metadata() inst_write_metadata.metadata = 0x20000000 inst_write_metadata.metadata_mask = 0xf0000000 testutils.write_goto(self, testutils.WC_SERV_TABLE, testutils.EX_L2_TABLE, ing_port, add_inst=inst_write_metadata) pkt_metadata = { 'metadata_val': inst_write_metadata.metadata, 'metadata_msk': inst_write_metadata.metadata_mask } match_fields = testutils.packet_to_exact_flow_match( pkt_metadata=pkt_metadata, table_id=testutils.EX_L2_TABLE) testutils.write_output(self, testutils.EX_L2_TABLE, egr_port, match_fields=match_fields) self.dataplane.send(ing_port, str(pkt)) (response, _) = self.controller.poll(ofp.OFPT_PACKET_IN, 2) self.assertTrue( response is not None, 'Packet in message not received on port ' + str(egr_port)) if str(pkt) != response.data: pa_logger.debug("pkt len " + str(len(str(pkt))) + ": " + str(pkt)) pa_logger.debug("resp len " + str(len(str(response.data))) + ": " + str(response.data))
def runTest(self): """ Add four flow entries: First Table; Match IP Src A; send to 1, goto Second Table Second Table; Match IP Src A; write metadata, goto Third Table Third Table; Match IP Src A and metadata; send to 2 // stop, do action Fourth Table; Match IP Src A; send to 1 // not match, just a trap Then send in 2 packets: IP A, TCP C; expect out port 2 IP A, TCP B; expect out port 2 @param self object instance @param EX_ACL_TABLE first table @param WC_ACL_TABLE second table @param WC_SERV_TABLE third table @param EX_VLAN_TABLE fourth table """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up first match testutils.write_goto_output(self, testutils.WC_ACL_TABLE, testutils.WC_SERV_TABLE, of_ports[0]) # Set up second match inst = instruction.instruction_write_metadata() inst.metadata = 0xfedcba9876543210 inst.metadata_mask = 0xffffffffffffffff testutils.write_goto(self, testutils.WC_SERV_TABLE, testutils.EX_L2_TABLE, of_ports[2], add_inst=inst) # Set up third match pkt_metadata = {'metadata_val':inst.metadata, 'metadata_msk':inst.metadata_mask} match_fields = testutils.packet_to_exact_flow_match(pkt_metadata = pkt_metadata, table_id = testutils.EX_L2_TABLE) testutils.write_output(self, testutils.EX_L2_TABLE, of_ports[1], match_fields=match_fields) # Set up fourth match #write_output(self, testutils.EX_VLAN_TABLE, of_ports[0]) # Generate a packet matching flow 1, 2, and 3; rcv on port[1] testutils.reply_check_dp(self, tcp_sport=1234, ing_port = of_ports[2], egr_port = of_ports[1])
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) > 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): 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(dl_src='00:01:02:03:04:05', dl_dst='00:06:07:08:09:0a') exp_pkt = testutils.simple_tcp_packet(dl_src='00:01:02:03:04:05', dl_dst='aa:aa:aa:aa:aa:aa') # get match list match_ls = testutils.packet_to_exact_flow_match(pkt=pkt, table_id=table_id, ing_port=port_in) act = action.action_set_field() field = match.eth_dst(parse.parse_mac("aa:aa:aa:aa:aa:aa")) act.field.add(field) exact_table_output(self, table_id, match_ls, actions=[act], egr_port=egr_port) testutils.do_barrier(self.controller) "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 is not None, "rec none packets") self.assertEqual(str(exp_pkt), str(pkt_rec), 'retruned pkt not equal to the original pkt')
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 flow_match_test_port_pair_vlan_two_tables(parent, ing_port, egr_port, wildcards=0, dl_vlan=-1, dl_vlan_pcp=0, dl_vlan_type=ETHERTYPE_VLAN, dl_vlan_int=-1, dl_vlan_pcp_int=0, vid_match_tbl0=ofp.OFPVID_NONE, pcp_match_tbl0=0, 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, vid_match_tbl1=ofp.OFPVID_NONE, pcp_match_tbl1=0, action_list_tbl1=None, 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, exp_vid=-1, exp_pcp=0, exp_vlan_type=ETHERTYPE_VLAN, add_tag_exp=False, pkt=None, exp_pkt=None): """ Flow match test for various vlan 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) + " vlan: " + str(dl_vlan) + " expire_table0: " + str(check_expire_tbl0) + " expire_table1: " + str(check_expire_tbl1)) if pkt is None: if dl_vlan > 0: if dl_vlan_int > 0: pkt = testutils.simple_tcp_packet( vlan_tags=[{'type': dl_vlan_type, 'vid': dl_vlan, 'pcp': dl_vlan_pcp}, {'type': dl_vlan_type, 'vid': dl_vlan_int, 'pcp': dl_vlan_pcp_int}]) else: pkt = testutils.simple_tcp_packet( vlan_tags=[{'type': dl_vlan_type, 'vid': dl_vlan, 'pcp': dl_vlan_pcp}]) else: pkt = testutils.simple_tcp_packet() if exp_pkt is None: if exp_vid > 0: if add_tag_exp: if dl_vlan > 0: if dl_vlan_int > 0: exp_pkt = testutils.simple_tcp_packet( vlan_tags=[{'type': dl_vlan_type, 'vid': dl_vlan, 'pcp': dl_vlan_pcp}, {'type': dl_vlan_type, 'vid': dl_vlan_int, 'pcp': dl_vlan_pcp_int}]) else: #Push one more tag in either case exp_pkt = testutils.simple_tcp_packet( vlan_tags=[{'type': exp_vlan_type, 'vid': exp_vid, 'pcp': exp_pcp}, {'type': dl_vlan_type, 'vid': dl_vlan, 'pcp': dl_vlan_pcp}]) else: exp_pkt = testutils.simple_tcp_packet( vlan_tags=[{'type': exp_vlan_type, 'vid': exp_vid, 'pcp': exp_pcp}]) else: if dl_vlan_int >= 0: exp_pkt = testutils.simple_tcp_packet( vlan_tags=[{'type': exp_vlan_type, 'vid': exp_vid, 'pcp': exp_pcp}, {'type': dl_vlan_type, 'vid': dl_vlan_int, 'pcp': dl_vlan_pcp_int}]) else: exp_pkt = testutils.simple_tcp_packet( vlan_tags=[{'type': exp_vlan_type, 'vid': exp_vid, 'pcp': exp_pcp}]) else: #subtract action if dl_vlan_int > 0: exp_pkt = testutils.simple_tcp_packet( vlan_tags=[{'type': dl_vlan_type, 'vid': dl_vlan_int, 'pcp': dl_vlan_pcp_int}]) else: exp_pkt = testutils.simple_tcp_packet() table_id0 = testutils.EX_ACL_TABLE if dl_vlan > 0: table_id0 = testutils.EX_VLAN_TABLE testutils.delete_all_flows(parent.controller,parent.logger) if table_id0 != testutils.EX_ACL_TABLE: testutils.set_table_config(parent,table_id0) match_ls = testutils.packet_to_exact_flow_match(pkt,None,table_id0,ing_port) parent.assertTrue(match_ls is not None, "Flow match from pkt failed") #match.wildcards = wildcards # Flow Mod for Table0 inst = instruction.instruction_goto_table() if table_id0 == testutils.EX_ACL_TABLE: table_id1 = testutils.EX_VLAN_TABLE else: table_id1 = testutils.WC_ALL_TABLE inst.table_id = table_id1 inst_list = [inst] request0 = testutils.flow_msg_create(parent, pkt, ing_port=ing_port, instruction_list=inst_list, action_list=action_list_tbl0, wildcards=wildcards, egr_port = ofp.OFPP_LOCAL, match_fields=match_ls, check_expire=check_expire_tbl0, inst_app_flag=testutils.APPLY_ACTIONS_INSTRUCTION, table_id=table_id0) testutils.flow_msg_install(parent, request0) if exp_msg_tbl0 is not ofp.OFPT_ERROR: response,_ = parent.controller.poll(ofp.OFPT_ERROR, 1) if response is not None: parent.assertTrue(response is None, "Rcv: Unexpected Error Message: type " + str(response.type) + ", code " + str(response.code)) # Flow Mod for Table1 pkt1 = testutils.simple_tcp_packet( vlan_tags=[{'type': exp_vlan_type, 'vid': exp_vid, 'pcp': exp_pcp}]) match_ls1 = testutils.packet_to_exact_flow_match(pkt1,None,table_id1,ing_port) for i in range(len(match_ls1.items)): if match_ls1.items[i].field == ofp.OFPXMT_OFB_VLAN_VID: if vid_match_tbl1 > ofp.OFPVID_NONE: match_ls1.items[i].value = vid_match_tbl1 + ofp.OFPVID_PRESENT break else: del match_ls1.items[i] break for i in range(len(match_ls1.items)): if match_ls1.items[i].field == ofp.OFPXMT_OFB_VLAN_PCP: if vid_match_tbl1 > ofp.OFPVID_NONE: match_ls1.items[i].value = pcp_match_tbl1 break else: del match_ls1.items[i] break request1 = testutils.flow_msg_create(parent, pkt, ing_port=ing_port, action_list=action_list_tbl1, wildcards=wildcards, match_fields=match_ls1, check_expire=check_expire_tbl1, table_id=table_id1, egr_port=egr_port) testutils.flow_msg_install(parent, request1) if exp_msg_tbl1 is not ofp.OFPT_ERROR: response,_ = parent.controller.poll(ofp.OFPT_ERROR, 1) if response is not None: parent.assertTrue(response is None, "Rcv: Unexpected Error Message: type " + str(response.type) + ", code " + str(response.code)) parent.logger.debug("Send packet: " + str(ing_port) + " to " + str(egr_port)) parent.dataplane.send(ing_port, str(pkt)) if match_exp_tbl0: if check_expire_tbl0: #@todo Not all HW supports both pkt and byte counters #@todo We shouldn't expect the order of coming response.. flow_removed_verify(parent, request0, pkt_count=1, byte_count=len(exp_pkt)) 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: #@todo Not all HW supports both pkt and byte counters #@todo We shouldn't expect the order of coming response.. flow_removed_verify(parent, request1, pkt_count=1, byte_count=len(exp_pkt)) 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)) 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 flow_match_test_port_pair_vlan_two_tables( parent, ing_port, egr_port, wildcards=0, dl_vlan=-1, dl_vlan_pcp=0, dl_vlan_type=ETHERTYPE_VLAN, dl_vlan_int=-1, dl_vlan_pcp_int=0, vid_match_tbl0=ofp.OFPVID_NONE, pcp_match_tbl0=0, 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, vid_match_tbl1=ofp.OFPVID_NONE, pcp_match_tbl1=0, action_list_tbl1=None, 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, exp_vid=-1, exp_pcp=0, exp_vlan_type=ETHERTYPE_VLAN, add_tag_exp=False, pkt=None, exp_pkt=None): """ Flow match test for various vlan 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) + " vlan: " + str(dl_vlan) + " expire_table0: " + str(check_expire_tbl0) + " expire_table1: " + str(check_expire_tbl1)) if pkt is None: if dl_vlan > 0: if dl_vlan_int > 0: pkt = testutils.simple_tcp_packet( vlan_tags=[{ 'type': dl_vlan_type, 'vid': dl_vlan, 'pcp': dl_vlan_pcp }, { 'type': dl_vlan_type, 'vid': dl_vlan_int, 'pcp': dl_vlan_pcp_int }]) else: pkt = testutils.simple_tcp_packet(vlan_tags=[{ 'type': dl_vlan_type, 'vid': dl_vlan, 'pcp': dl_vlan_pcp }]) else: pkt = testutils.simple_tcp_packet() if exp_pkt is None: if exp_vid > 0: if add_tag_exp: if dl_vlan > 0: if dl_vlan_int > 0: exp_pkt = testutils.simple_tcp_packet( vlan_tags=[{ 'type': dl_vlan_type, 'vid': dl_vlan, 'pcp': dl_vlan_pcp }, { 'type': dl_vlan_type, 'vid': dl_vlan_int, 'pcp': dl_vlan_pcp_int }]) else: #Push one more tag in either case exp_pkt = testutils.simple_tcp_packet( vlan_tags=[{ 'type': exp_vlan_type, 'vid': exp_vid, 'pcp': exp_pcp }, { 'type': dl_vlan_type, 'vid': dl_vlan, 'pcp': dl_vlan_pcp }]) else: exp_pkt = testutils.simple_tcp_packet( vlan_tags=[{ 'type': exp_vlan_type, 'vid': exp_vid, 'pcp': exp_pcp }]) else: if dl_vlan_int >= 0: exp_pkt = testutils.simple_tcp_packet( vlan_tags=[{ 'type': exp_vlan_type, 'vid': exp_vid, 'pcp': exp_pcp }, { 'type': dl_vlan_type, 'vid': dl_vlan_int, 'pcp': dl_vlan_pcp_int }]) else: exp_pkt = testutils.simple_tcp_packet( vlan_tags=[{ 'type': exp_vlan_type, 'vid': exp_vid, 'pcp': exp_pcp }]) else: #subtract action if dl_vlan_int > 0: exp_pkt = testutils.simple_tcp_packet( vlan_tags=[{ 'type': dl_vlan_type, 'vid': dl_vlan_int, 'pcp': dl_vlan_pcp_int }]) else: exp_pkt = testutils.simple_tcp_packet() table_id0 = testutils.EX_ACL_TABLE if dl_vlan > 0: table_id0 = testutils.EX_VLAN_TABLE testutils.delete_all_flows(parent.controller, parent.logger) if table_id0 != testutils.EX_ACL_TABLE: testutils.set_table_config(parent, table_id0) match_ls = testutils.packet_to_exact_flow_match(pkt, None, table_id0, ing_port) parent.assertTrue(match_ls is not None, "Flow match from pkt failed") #match.wildcards = wildcards # Flow Mod for Table0 inst = instruction.instruction_goto_table() if table_id0 == testutils.EX_ACL_TABLE: table_id1 = testutils.EX_VLAN_TABLE else: table_id1 = testutils.WC_ALL_TABLE inst.table_id = table_id1 inst_list = [inst] request0 = testutils.flow_msg_create( parent, pkt, ing_port=ing_port, instruction_list=inst_list, action_list=action_list_tbl0, wildcards=wildcards, egr_port=ofp.OFPP_LOCAL, match_fields=match_ls, check_expire=check_expire_tbl0, inst_app_flag=testutils.APPLY_ACTIONS_INSTRUCTION, table_id=table_id0) testutils.flow_msg_install(parent, request0) if exp_msg_tbl0 is not ofp.OFPT_ERROR: response, _ = parent.controller.poll(ofp.OFPT_ERROR, 1) if response is not None: parent.assertTrue( response is None, "Rcv: Unexpected Error Message: type " + str(response.type) + ", code " + str(response.code)) # Flow Mod for Table1 pkt1 = testutils.simple_tcp_packet(vlan_tags=[{ 'type': exp_vlan_type, 'vid': exp_vid, 'pcp': exp_pcp }]) match_ls1 = testutils.packet_to_exact_flow_match(pkt1, None, table_id1, ing_port) for i in range(len(match_ls1.items)): if match_ls1.items[i].field == ofp.OFPXMT_OFB_VLAN_VID: if vid_match_tbl1 > ofp.OFPVID_NONE: match_ls1.items[i].value = vid_match_tbl1 + ofp.OFPVID_PRESENT break else: del match_ls1.items[i] break for i in range(len(match_ls1.items)): if match_ls1.items[i].field == ofp.OFPXMT_OFB_VLAN_PCP: if vid_match_tbl1 > ofp.OFPVID_NONE: match_ls1.items[i].value = pcp_match_tbl1 break else: del match_ls1.items[i] break request1 = testutils.flow_msg_create(parent, pkt, ing_port=ing_port, action_list=action_list_tbl1, wildcards=wildcards, match_fields=match_ls1, check_expire=check_expire_tbl1, table_id=table_id1, egr_port=egr_port) testutils.flow_msg_install(parent, request1) if exp_msg_tbl1 is not ofp.OFPT_ERROR: response, _ = parent.controller.poll(ofp.OFPT_ERROR, 1) if response is not None: parent.assertTrue( response is None, "Rcv: Unexpected Error Message: type " + str(response.type) + ", code " + str(response.code)) parent.logger.debug("Send packet: " + str(ing_port) + " to " + str(egr_port)) parent.dataplane.send(ing_port, str(pkt)) if match_exp_tbl0: if check_expire_tbl0: #@todo Not all HW supports both pkt and byte counters #@todo We shouldn't expect the order of coming response.. flow_removed_verify(parent, request0, pkt_count=1, byte_count=len(exp_pkt)) 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: #@todo Not all HW supports both pkt and byte counters #@todo We shouldn't expect the order of coming response.. flow_removed_verify(parent, request1, pkt_count=1, byte_count=len(exp_pkt)) 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)) 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_fields = 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_fields 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] match_fields = testutils.packet_to_exact_flow_match(pkt,None,table_id,ing_port) 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_fields=match_fields, check_expire=check_expire, table_id=table_id) request_list.append(request) #print("request::\n%s" % request_list[table_id].show()) testutils.flow_msg_install(parent, request_list[table_id], True) 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=len(pkt)) testutils.receive_pkt_verify(parent, egr_port, exp_pkt)
def runTest(self): vlan_tags = [{'type': 0x8100, 'vid': 1, 'pcp': 1}] #mpls_tags=[{'type': 0x8847, 'label': 22, 'tc': 2, 'ttl': 48}] pkt = testutils.simple_icmp_packet(dl_dst='00:01:02:03:04:05', dl_src='00:06:07:08:09:0a', vlan_tags=vlan_tags, mpls_tags=[], ip_src='192.168.0.55', ip_dst='192.168.3.254', ip_tos=5, ip_ttl=47, icmp_type=8, icmp_code=0, payload_len=100) of_ports = exact_port_map.keys() for dp_port1 in of_ports: ing_port = dp_port1 for dp_port2 in of_ports: if dp_port2 != dp_port1: egr_port = dp_port2 #match_ls = testutils.packet_to_exact_flow_match(pkt, None, testutils.EX_ACL_TABLE, ing_port) #exact_table_goto_table(self, testutils.EX_ACL_TABLE, testutils.WC_ACL_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match( pkt, None, testutils.WC_ACL_TABLE, ing_port) exact_table_goto_table(self, testutils.WC_ACL_TABLE, testutils.WC_SERV_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match( pkt, None, testutils.WC_SERV_TABLE, ing_port) exact_table_goto_table(self, testutils.WC_SERV_TABLE, testutils.EX_L2_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match( pkt, None, testutils.EX_L2_TABLE, ing_port) exact_table_goto_table(self, testutils.EX_L2_TABLE, testutils.EX_VLAN_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match( pkt, None, testutils.EX_VLAN_TABLE, ing_port) exact_table_goto_table(self, testutils.EX_VLAN_TABLE, testutils.EX_MPLS_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match( pkt, None, testutils.EX_MPLS_TABLE, ing_port) exact_table_goto_table(self, testutils.EX_MPLS_TABLE, testutils.EX_L3_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match( pkt, None, testutils.EX_L3_TABLE, ing_port) exact_table_goto_table(self, testutils.EX_L3_TABLE, testutils.WC_L3_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match( pkt, None, testutils.WC_L3_TABLE, ing_port) exact_table_goto_table(self, testutils.WC_L3_TABLE, testutils.EX_ICMP_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match( pkt, None, testutils.EX_ICMP_TABLE, ing_port) exact_table_goto_table(self, testutils.EX_ICMP_TABLE, testutils.WC_ALL_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match( pkt, None, testutils.WC_ALL_TABLE, ing_port) exact_table_output(self, testutils.WC_ALL_TABLE, match_ls, egr_port=egr_port) self.dataplane.send(ing_port, str(pkt)) testutils.receive_pkt_verify(self, egr_port, pkt)