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): #async_logger.info("Running Async_NoPacketIn") #verifying without set_async_request, switch will packet in #step 1-1:clear all flow entries for unmatching of_ports = testutils.clear_switch(self, async_port_map.keys(), async_logger) #step 2-1:controller sends set_async_request msg async_logger.info("Sending set_async_request") mask = 1 << ofp.OFPR_NO_MATCH request_set = create_set_async(pkt_in_mstr = mask) #print(request_set.show()) set_async_verify(self, request_set) #result 2-1: contrller sends msg successfully #no match default deal:drop; add flow entry to packet_in #step 3-1: install default mismatch flow entry ,action=packetin; testutils.set_table_config(self, config = ofp.OFPTC_TABLE_MISS_CONTROLLER) #send data to port for of_port in of_ports: async_logger.info("PKT IN test, port " + str(of_port)) pkt = testutils.simple_tcp_packet() self.dataplane.send(of_port, str(pkt)) #@todo Check for unexpected messages? testutils.packetin_verify(self, pkt) #print(response) #"verifying with set_async_request, switch will packet in" #step 1-2:clear all flow entries for unmatching rc = testutils.clear_switch(self, async_port_map.keys(), async_logger) #step 2-2:controller sends set_async_request msg async_logger.info("Sending set_async_request") mask = 0xffffffff ^ (1 << ofp.OFPR_NO_MATCH) request_set = create_set_async(pkt_in_mstr = mask) set_async_verify(self, request_set) #print("2-2 request_set"+request_set.show()) #result 2-2: contrller sends msg successfully #no match default deal:drop; add flow entry to packet_in #step 3-2: install default mismatch flow entry ,action=packetin; testutils.set_table_config(self, config = ofp.OFPTC_TABLE_MISS_CONTROLLER) #(response, _) = self.controller.poll(ofp.OFPT_PACKET_IN, 2) #send data to port for of_port in async_port_map.keys(): async_logger.info("PKT IN test, port " + str(of_port)) pkt = testutils.simple_tcp_packet() self.dataplane.send(of_port, str(pkt)) #@todo Check for unexpected messages? (response, _) = self.controller.poll(ofp.OFPT_PACKET_IN, 2) #print(response) self.assertTrue(response is None, 'Packet in message received unexpected') msg = create_set_async() set_async_verify(self, msg)
def runTest(self): #async_logger.info("Running " + str(self)) #step 0:clear switch of_ports = testutils.clear_switch(self, async_port_map.keys(), async_logger) (response, _) = self.controller.poll(ofp.OFPT_PORT_STATUS, 2) (response, _) = self.controller.poll(ofp.OFPT_PORT_STATUS, 2) (response, _) = self.controller.poll(ofp.OFPT_PORT_STATUS, 2) #step 1:controller sends set_async_request msg async_logger.info("Sending set_async_request") mask = 0xffffffff ^ (1 << ofp.OFPPR_MODIFY) request_set = create_set_async(port_st_mstr = mask) testutils.ofmsg_send(self, request_set) #result 1: contrller sends msg successfully #step 2: set the first port's config to the other way async_logger.info("testcase executed on port: " + str(of_ports[0])) async_logger.debug("No flood bit port " + str(of_ports[0]) + " is now " + str(ofp.OFPPC_NO_PACKET_IN)) rv = testutils.port_config_set(self.controller, of_ports[0], ofp.OFPPC_NO_PACKET_IN, ofp.OFPPC_NO_PACKET_IN, async_logger) #result 2:set the first port's config to the other way successfully self.assertTrue(rv != -1, "Error sending port mod") testutils.do_barrier(self.controller) #step 3: after the port's attribute changed, PORT_STATUS msg sended to controller (response, _) = self.controller.poll(ofp.OFPT_PORT_STATUS, 2) #result 3: no packetin msg sended to controller self.assertTrue(response is None, 'PORT_STATUS message received unexpected') #step 4: Verify change took place with same feature request _,config,_ = testutils.port_config_get(self.controller, of_ports[0], async_logger) async_logger.debug("No packet_in bit port " + str(of_ports[0]) + " is now " + str(config & ofp.OFPPC_NO_PACKET_IN)) self.assertTrue(config is not None, "Did not get port config") self.assertTrue(config & ofp.OFPPC_NO_PACKET_IN != 0, "Bit change did not take") #step 5: Set it back mask = 1 << ofp.OFPPR_MODIFY request_set = create_set_async(port_st_mstr = mask) testutils.ofmsg_send(self, request_set) rv = testutils.port_config_set(self.controller, of_ports[0], 0, ofp.OFPPC_NO_PACKET_IN, async_logger) self.assertTrue(rv != -1, "Error sending port mod") (response, _) = self.controller.poll(ofp.OFPT_PORT_STATUS, 2) #result 3: no packetin msg sended to controller self.assertTrue(response is not None, 'PORT_STATUS message not received') testutils.clear_switch(self, async_port_map, async_logger) msg = create_set_async() set_async_verify(self, msg)
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): # Construct packet to send to dataplane # Send packet to dataplane # Poll controller with expect message type packet in of_ports = testutils.clear_switch(self, basic_port_map.keys(), basic_logger) # These will get put into function outpkt = testutils.simple_tcp_packet() of_ports = basic_port_map.keys() of_ports.sort() for dp_port in of_ports: msg = message.packet_out() msg.in_port = ofp.OFPP_CONTROLLER msg.data = str(outpkt) act = action.action_output() act.port = dp_port self.assertTrue(msg.actions.add(act), 'Could not add action to msg') basic_logger.info("PacketOut to: " + str(dp_port)) testutils.ofmsg_send(self, msg) (of_port, pkt, _) = self.dataplane.poll(timeout=1) self.assertTrue(pkt is not None, 'Packet not received') basic_logger.info("PacketOut: got pkt from " + str(of_port)) if of_port is not None: self.assertEqual(of_port, dp_port, "Unexpected receive port") self.assertEqual(str(outpkt), str(pkt), 'Response packet does not match send packet')
def runTest(self): """ 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 @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(self, testutils.EX_ACL_TABLE, testutils.WC_ACL_TABLE) # Set up second match testutils.write_goto_output(self, testutils.WC_ACL_TABLE, testutils.WC_SERV_TABLE, of_ports[0]) # Set up third match testutils.write_output(self, testutils.WC_SERV_TABLE, of_ports[1], of_ports[2]) # 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[1])
def scenario4(self, first_table = 0, second_table = 1, third_table = 2, fourth_table = 3): """ Add five flow entries: First Table; Match IP Src A; send to 1 Second Table; Match IP Src B; send to 1 Third Table; Match IP Src C; send to 1 Fourth Table; Match IP Src D; send to 1 Then send in 2 packets: IP F, TCP C; expect packet_in IP G, TCP B; expect packet_in @param self object instance @param first_table first table @param second_table second table @param third_table third table @param fourth_table fourth table """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up matches write_output(self, first_table, of_ports[0], ip_src="192.168.1.10") write_output(self, second_table, of_ports[0], ip_src="192.168.1.20") write_output(self, third_table, of_ports[0], ip_src="192.168.1.30") write_output(self, fourth_table, of_ports[0], ip_src="192.168.1.40") # Generate a packet not matching to any flow, then packet_in reply_check_ctrl(self, ip_src='192.168.1.70', tcp_sport=10, ing_port = of_ports[2])
def runTest(self): of_ports = testutils.clear_switch(self, basic_port_map.keys(), basic_logger) for max_len in [ 0, 99, DEFAULT_MISS_SEND_LEN, ofp.OFPCML_MAX, ofp.OFPCML_NO_BUFFER ]: rc = testutils.delete_all_flows(self.controller, basic_logger) self.assertEqual(rc, 0, "Failed to delete all flows") testutils.set_config_verify(self, max_len=(max_len % ofp.OFPCML_MAX + 10)) if max_len == ofp.OFPCML_NO_BUFFER: testutils.set_config_verify(self, max_len=max_len) testutils.set_flow_miss_entry(self, ofp.OFPTC_TABLE_MISS_CONTROLLER, max_len, 0) for of_port in basic_port_map.keys(): basic_logger.info("PKT IN test, port " + str(of_port)) pkt = testutils.simple_tcp_packet() self.dataplane.send(of_port, str(pkt)) #@todo Check for unexpected messages? testutils.do_barrier(self.controller) testutils.packetin_verify(self, pkt, max_len) response, _ = self.controller.poll(ofp.OFPT_PACKET_IN, 1) while response != None: response, _ = self.controller.poll(ofp.OFPT_PACKET_IN, 1) testutils.set_config_verify(self, max_len=DEFAULT_MISS_SEND_LEN)
def runTest(self): """ Set the first table config as "Send to Controller" and the second table as "Drop", add flow entries: First Table; Match IP Src A; send to 1 // if not match, packet_in Second Table; Match IP Src B; send to 2 // if not match, drop Then send a packet: IP B; expect packet_in """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set table config as "send to controller" and "drop" testutils.set_table_config(self, testutils.WC_ACL_TABLE, ofp.OFPTC_TABLE_MISS_CONTROLLER, True) testutils.set_table_config(self, testutils.WC_SERV_TABLE, ofp.OFPTC_TABLE_MISS_DROP, True) # Set up matches testutils.write_output(self, testutils.WC_ACL_TABLE, of_ports[0], ip_src="192.168.1.10") testutils.write_output(self, testutils.WC_SERV_TABLE, of_ports[1], of_ports[2], ip_src="192.168.1.70") # Generate a packet not matching to any flow entry in the first table testutils.reply_check_ctrl(self, ip_src='192.168.1.70', tcp_sport=1234, ing_port=of_ports[2])
def runTest(self): """ Set table config as "Continue" and add flow entry: First Table; Match IP Src A; send to 1 // not match then continue Second Table; Match IP Src B; send to 2 // do execution Then send in 2 packets: IP B; expect out port 2 """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set table config as "continue" testutils.set_table_config(self, testutils.WC_ACL_TABLE, ofp.OFPTC_TABLE_MISS_CONTINUE, True) # Set up flow entries #write_output(self, testutils.EX_ACL_TABLE, of_ports[0], ip_src="192.168.1.10") testutils.write_output(self, testutils.WC_ACL_TABLE, of_ports[0], ip_src="192.168.1.10") testutils.write_output(self, testutils.WC_SERV_TABLE, of_ports[1], of_ports[2], ip_src="192.168.1.70") testutils.do_barrier(self.controller) # Generate a packet not matching in the first table, but in the second testutils.reply_check_dp(self, ip_src='192.168.1.70', tcp_sport=1234, ing_port=of_ports[2], egr_port=of_ports[1])
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): """ Add five flow entries: First Table; Match IP Src A; send to 1 Second Table; Match IP Src B; send to 1 Third Table; Match IP Src C; send to 1 Fourth Table; Match IP Src D; send to 1 Then send in 2 packets: IP F, TCP C; expect packet_in IP G, TCP B; expect packet_in @param self object instance @param first_table first table @param second_table second table @param third_table third table @param fourth_table fourth table """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up matches #write_output(self, testutils.EX_ACL_TABLE, 1, ip_src="192.168.1.10") #write_output(self, testutils.EX_ACL_TABLE, of_ports[0], ip_src="128.128.128.10") testutils.set_table_config(self, config = ofp.OFPTC_TABLE_MISS_CONTROLLER) testutils.write_output(self, testutils.WC_ACL_TABLE, of_ports[0], ip_src="192.168.1.10") testutils.write_output(self, testutils.WC_SERV_TABLE, of_ports[0], ing_port=of_ports[1], ip_src="192.168.1.20") testutils.write_output(self, testutils.EX_L2_TABLE, of_ports[0], ip_src="192.168.1.30") testutils.write_output(self, testutils.EX_L3_TABLE, of_ports[0], ip_src="192.168.1.40") # Generate a packet not matching to any flow, then packet_in testutils.reply_check_ctrl(self, ip_src='192.168.1.70', tcp_sport=1234, ing_port = of_ports[2])
def runTest(self): """ Set the first table config as "Drop" and second table as "Controller" add flow entry: First Table; Match IP Src A; send to 1 // if not match, then drop Second Table; Match IP Src B; send to 2 // if not match, controller Then send in a packet: IP B; expect drop """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set table config as "drop" and "send to controller" testutils.set_table_config(self, testutils.WC_ACL_TABLE, ofp.OFPTC_TABLE_MISS_DROP, True) testutils.set_table_config(self, testutils.WC_SERV_TABLE, ofp.OFPTC_TABLE_MISS_CONTROLLER, True) # Set up first match testutils.write_output(self, testutils.WC_ACL_TABLE, of_ports[0], ip_src="192.168.1.10") testutils.write_output(self, testutils.WC_SERV_TABLE, of_ports[1], of_ports[2], ip_src="192.168.1.70") # Generate a packet not matching to any flow, then drop pkt = testutils.simple_tcp_packet(ip_src='192.168.1.70', tcp_sport=10) self.dataplane.send(of_ports[2], 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 scenario2(self, first_table=0, second_table=1): """ Set the first table config as "Drop" and second table as "Controller" add flow entry: First Table; Match IP Src A; send to 1 // if not match, then drop Second Table; Match IP Src B; send to 2 // if not match, controller Then send in a packet: IP B; expect drop """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set table config as "drop" and "send to controller" setup_table_config(self, first_table, ofp.OFPTC_TABLE_MISS_DROP) setup_table_config(self, second_table, ofp.OFPTC_TABLE_MISS_CONTROLLER) # Set up first match write_output(self, first_table, of_ports[0], ip_src="192.168.1.10") write_output(self, second_table, of_ports[1], ip_src="192.168.1.70") # Generate a packet not matching to any flow, then drop pkt = testutils.simple_tcp_packet(ip_src='192.168.1.70', tcp_sport=10) self.dataplane.send(of_ports[2], 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 scenario3(self, first_table=0, second_table=1, third_table=2): """ Add three flow entries: First Table; Match IP Src A; send to 0 now, goto Second Table Second Table; Match IP Src A; send to 1 now, goto Third Table Third Table; Match IP src A; send to 2 now Then send a packet: IP A; expect out port 0, 1, and 2 @param self object instance @param first_table first table @param second_table second table @param third_table third table """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up matches inst = instruction.instruction_goto_table() inst.table_id = second_table self.set_apply_output(first_table, of_ports[0], inst) # Set up second match inst.table_id = third_table self.set_apply_output(second_table, of_ports[1], inst) # Set up third match self.set_apply_output(third_table, of_ports[2]) # Generate a packet and receive 3 responses pkt = testutils.simple_tcp_packet(ip_src=MT_TEST_IP, tcp_sport=10) self.dataplane.send(of_ports[3], str(pkt)) testutils.receive_pkt_verify(self, of_ports[0], pkt) testutils.receive_pkt_verify(self, of_ports[1], pkt) testutils.receive_pkt_verify(self, of_ports[2], pkt)
def scenario3(self, first_table = 0, second_table = 1, third_table = 2): """ Add three flow entries: First Table; Match IP Src A; send to 0 now, goto Second Table Second Table; Match IP Src A; send to 1 now, goto Third Table Third Table; Match IP src A; send to 2 now Then send a packet: IP A; expect out port 0, 1, and 2 @param self object instance @param first_table first table @param second_table second table @param third_table third table """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up matches inst = instruction.instruction_goto_table() inst.table_id = second_table self.set_apply_output(first_table, of_ports[0], inst) # Set up second match inst.table_id = third_table self.set_apply_output(second_table, of_ports[1], inst) # Set up third match self.set_apply_output(third_table, of_ports[2]) # Generate a packet and receive 3 responses pkt = testutils.simple_tcp_packet(ip_src=MT_TEST_IP, tcp_sport=10) self.dataplane.send(of_ports[3], str(pkt)) testutils.receive_pkt_verify(self, of_ports[0], pkt) testutils.receive_pkt_verify(self, of_ports[1], pkt) testutils.receive_pkt_verify(self, of_ports[2], pkt)
def scenario4(self, first_table=0, second_table=1, third_table=2, fourth_table=3): """ Add five flow entries: First Table; Match IP Src A; send to 1 Second Table; Match IP Src B; send to 1 Third Table; Match IP Src C; send to 1 Fourth Table; Match IP Src D; send to 1 Then send in 2 packets: IP F, TCP C; expect packet_in IP G, TCP B; expect packet_in @param self object instance @param first_table first table @param second_table second table @param third_table third table @param fourth_table fourth table """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up matches write_output(self, first_table, of_ports[0], ip_src="192.168.1.10") write_output(self, second_table, of_ports[0], ip_src="192.168.1.20") write_output(self, third_table, of_ports[0], ip_src="192.168.1.30") write_output(self, fourth_table, of_ports[0], ip_src="192.168.1.40") # Generate a packet not matching to any flow, then packet_in reply_check_ctrl(self, ip_src='192.168.1.70', tcp_sport=10, ing_port=of_ports[2])
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 = 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 scenario2(self, first_table=0, second_table=1): """ Set the first table config as "Send to Controller" and the second table as "Drop", add flow entries: First Table; Match IP Src A; send to 1 // if not match, packet_in Second Table; Match IP Src B; send to 2 // if not match, drop Then send a packet: IP B; expect packet_in """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set table config as "send to controller" and "drop" setup_table_config(self, first_table, ofp.OFPTC_TABLE_MISS_CONTROLLER) setup_table_config(self, second_table, ofp.OFPTC_TABLE_MISS_DROP) # Set up matches write_output(self, first_table, of_ports[0], ip_src="192.168.1.10") write_output(self, second_table, of_ports[1], ip_src="192.168.1.70") # Generate a packet not matching to any flow entry in the first table reply_check_ctrl(self, ip_src='192.168.1.70', tcp_sport=10, ing_port=of_ports[2])
def scenario2(self, first_table=0, second_table=1, tos1=4, tos2=8): """ Add flow entries: First Table; Match IP Src A; set ToS = tos1, goto Second Table First Table; Match IP Src B; set ToS = tos2, goto Second Table Second Table; Match IP Src A; send to 1 Second Table; Match IP Src B; send to 1 Then send packets: IP A; expect port 1 with ToS = tos1 IP B; expect port 1 with ToS = tos2 @param self object instance @param first_table first table @param second_table second table @param tos1 ToS value to be set for first flow @param tos2 ToS value to be set for second flow """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up flow match in table A: set ToS t_act = action.action_set_nw_tos() t_act.nw_tos = tos1 write_goto_action(self, first_table, second_table, t_act, ip_src='192.168.1.10') t_act.nw_tos = tos2 write_goto_action(self, first_table, second_table, t_act, ip_src='192.168.1.30') # Set up flow matches in table B: routing write_output(self, second_table, of_ports[1], ip_src="192.168.1.10") write_output(self, second_table, of_ports[1], ip_src="192.168.1.30") # Generate packets and check them exp_pkt = testutils.simple_tcp_packet(ip_src='192.168.1.10', tcp_sport=10, ip_tos=tos1) reply_check_dp(self, ip_src='192.168.1.10', tcp_sport=10, exp_pkt=exp_pkt, ing_port=of_ports[2], egr_port=of_ports[1]) exp_pkt = testutils.simple_tcp_packet(ip_src='192.168.1.30', tcp_sport=10, ip_tos=tos2) reply_check_dp(self, ip_src='192.168.1.30', tcp_sport=10, exp_pkt=exp_pkt, ing_port=of_ports[2], egr_port=of_ports[1])
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): # 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 scenario4(self, first_table=0, second_table=1, third_table=2, fourth_table=3): """ ** 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 @param self object instance @param first_table first table @param second_table second table @param third_table third table @param fourth_table fourth table """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up first match write_goto(self, first_table, second_table) # Set up second match write_goto_output(self, second_table, third_table, of_ports[0]) # Set up third match, "Empty Instruction" request = message.flow_mod() request.match = make_match() request.buffer_id = 0xffffffff request.table_id = third_table pa_logger.info("Inserting flow 3") rv = self.controller.message_send(request) self.assertTrue(rv != -1, "Error installing flow mod") testutils.do_barrier(self.controller) # Set up fourth match write_output(self, fourth_table, of_ports[1]) # Generate a packet matching flow 1, 2, and 3; rcv on port[0] reply_check_dp(self, tcp_sport=10, ing_port=of_ports[2], egr_port=of_ports[0]) # Generate a packet matching flow 1, 2, and 3; rcv on port[0] reply_check_dp(self, tcp_sport=80, ing_port=of_ports[2], egr_port=of_ports[0])
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 scenario4(self, first_table=0, second_table=1, third_table=2, fourth_table=3): """ 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 first_table first table @param second_table second table @param third_table third table @param fourth_table fourth table """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up first match write_goto_output(self, first_table, second_table, of_ports[0]) # Set up second match inst = instruction.instruction_write_metadata() inst.metadata = 0xfedcba9876543210 inst.metadata_mask = 0xffffffffffffffff write_goto(self, second_table, third_table, add_inst=inst) # Set up third match match = make_match() match.metadata = 0xfedcba9876543210 match.metadata_mask = 0xffffffffffffffff write_output(self, third_table, of_ports[1], match=match) # Set up fourth match write_output(self, fourth_table, of_ports[0]) # Generate a packet matching flow 1, 2, and 3; rcv on port[1] reply_check_dp(self, tcp_sport=10, ing_port=of_ports[2], egr_port=of_ports[1]) # Generate a packet matching flow 1, 2, and 3; rcv on port[1] reply_check_dp(self, tcp_sport=80, ing_port=of_ports[2], egr_port=of_ports[1])
def runTest(self): """ 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; clear action, goto Fourth Table Fourth Table; Match IP Src A; send to 2 Then send in 2 packets: IP A, TCP C; expect out port 1 IP A, TCP B; expect out port 1 @param self object instance @param EX_ACL_TABLE first table @param WC_ACL_TABLE second table @param WC_SERV_TABLE third table @param EX_L2_TABLE fourth table """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up first match #write_goto(self, testutils.EX_ACL_TABLE, testutils.WC_ACL_TABLE) act = action.action_set_field() field = match.eth_src(parse.parse_mac("aa:aa:aa:aa:aa:aa")) act.field.add(field) testutils.write_goto_action(self, testutils.WC_ACL_TABLE, testutils.WC_SERV_TABLE, act=act) # Set up second match testutils.write_goto_output(self, testutils.WC_SERV_TABLE, testutils.EX_L3_TABLE, of_ports[0], of_ports[2]) # Set up third match, "Clear Action" inst = instruction.instruction_clear_actions() testutils.write_goto(self, testutils.EX_L3_TABLE, testutils.WC_L3_TABLE, of_ports[2], add_inst=inst) # Set up fourth match testutils.write_output(self, testutils.WC_L3_TABLE, of_ports[1]) #write_output(self, testutils.EX_L2_TABLE, 4) # 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): """ Add five flow entries: First Table; Match IP Src A; send to 1 Second Table; Match IP Src B; send to 1 Third Table; Match IP Src C; send to 1 Fourth Table; Match IP Src D; send to 1 Then send in 2 packets: IP F, TCP C; expect packet_in IP G, TCP B; expect packet_in @param self object instance @param first_table first table @param second_table second table @param third_table third table @param fourth_table fourth table """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up matches #write_output(self, testutils.EX_ACL_TABLE, 1, ip_src="192.168.1.10") #write_output(self, testutils.EX_ACL_TABLE, of_ports[0], ip_src="128.128.128.10") testutils.set_table_config(self, config=ofp.OFPTC_TABLE_MISS_CONTROLLER) testutils.write_output(self, testutils.WC_ACL_TABLE, of_ports[0], ip_src="192.168.1.10") testutils.write_output(self, testutils.WC_SERV_TABLE, of_ports[0], ing_port=of_ports[1], ip_src="192.168.1.20") testutils.write_output(self, testutils.EX_L2_TABLE, of_ports[0], ip_src="192.168.1.30") testutils.write_output(self, testutils.EX_L3_TABLE, of_ports[0], ip_src="192.168.1.40") # Generate a packet not matching to any flow, then packet_in testutils.reply_check_ctrl(self, ip_src='192.168.1.70', tcp_sport=1234, ing_port=of_ports[2])
def runTest(self): # Construct packet to send to dataplane # Send packet to dataplane # Poll controller with expect message type packet in of_ports = testutils.clear_switch(self, basic_port_map.keys(), basic_logger) max_len = 40 testutils.set_flow_miss_entry(self, ofp.OFPTC_TABLE_MISS_CONTROLLER, max_len, 0) # These will get put into function outpkt = testutils.simple_tcp_packet() of_ports = basic_port_map.keys() of_ports.sort() #_,miss_send_len = testutils.get_config_reply_verify(self) #testutils.set_config_verify(self, max_len = 40) for dp_port in of_ports: (response, _) = self.controller.poll(ofp.OFPT_PACKET_IN, 2) for egr_port in of_ports: if egr_port != dp_port: break #_,max_len = testutils.get_config_reply_verify(self) self.dataplane.send(egr_port, str(outpkt)) testutils.do_barrier(self.controller) buffer_id = testutils.packetin_verify(self, outpkt, max_len) response, _ = self.controller.poll(ofp.OFPT_PACKET_IN, 1) while response != None: response, _ = self.controller.poll(ofp.OFPT_PACKET_IN, 1) msg = message.packet_out() msg.in_port = ofp.OFPP_CONTROLLER msg.buffer_id = buffer_id act = action.action_output() act.port = dp_port self.assertTrue(msg.actions.add(act), 'Could not add action to msg') basic_logger.info("PacketOut to: " + str(dp_port)) testutils.ofmsg_send(self, msg) (of_port, pkt, _) = self.dataplane.poll(timeout=3) self.assertTrue(pkt is not None, 'Packet not received') basic_logger.info("PacketOut: got pkt from " + str(of_port)) if of_port is not None: self.assertEqual(of_port, dp_port, "Unexpected receive port") self.assertEqual(str(outpkt), str(pkt), 'Response packet does not match send packet')
def scenario4(self, first_table = 0, second_table = 1, third_table = 2, fourth_table = 3): """ ** 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 @param self object instance @param first_table first table @param second_table second table @param third_table third table @param fourth_table fourth table """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up first match write_goto(self, first_table, second_table) # Set up second match write_goto_output(self, second_table, third_table, of_ports[0]) # Set up third match, "Empty Instruction" request = message.flow_mod() request.match = make_match() request.buffer_id = 0xffffffff request.table_id = third_table pa_logger.info("Inserting flow 3") rv = self.controller.message_send(request) self.assertTrue(rv != -1, "Error installing flow mod") testutils.do_barrier(self.controller) # Set up fourth match write_output(self, fourth_table, of_ports[1]) # Generate a packet matching flow 1, 2, and 3; rcv on port[0] reply_check_dp(self, tcp_sport=10, ing_port = of_ports[2], egr_port = of_ports[0]) # Generate a packet matching flow 1, 2, and 3; rcv on port[0] reply_check_dp(self, tcp_sport=80, ing_port = of_ports[2], egr_port = of_ports[0])
def runTest(self): 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[1]) # Set up third match testutils.write_output(self, testutils.EX_L2_TABLE, of_ports[2]) # Generate a packet and receive 3 responses pkt = testutils.simple_tcp_packet(ip_src = testutils.MT_TEST_IP) self.dataplane.send(of_ports[1], str(pkt)) testutils.receive_pkt_verify(self, of_ports[2], pkt)
def runTest(self): # Construct packet to send to dataplane # Send packet to dataplane # Poll controller with expect message type packet in of_ports = testutils.clear_switch(self, basic_port_map.keys(), basic_logger) max_len = 40 testutils.set_flow_miss_entry(self, ofp.OFPTC_TABLE_MISS_CONTROLLER, max_len, 0) # These will get put into function outpkt = testutils.simple_tcp_packet() of_ports = basic_port_map.keys() of_ports.sort() #_,miss_send_len = testutils.get_config_reply_verify(self) #testutils.set_config_verify(self, max_len = 40) for dp_port in of_ports: (response, _) = self.controller.poll(ofp.OFPT_PACKET_IN, 2) for egr_port in of_ports: if egr_port != dp_port: break #_,max_len = testutils.get_config_reply_verify(self) self.dataplane.send(egr_port, str(outpkt)) testutils.do_barrier(self.controller) buffer_id = testutils.packetin_verify(self, outpkt, max_len) response,_ = self.controller.poll(ofp.OFPT_PACKET_IN, 1) while response != None: response,_ = self.controller.poll(ofp.OFPT_PACKET_IN, 1) msg = message.packet_out() msg.in_port = ofp.OFPP_CONTROLLER msg.buffer_id = buffer_id act = action.action_output() act.port = dp_port self.assertTrue(msg.actions.add(act), 'Could not add action to msg') basic_logger.info("PacketOut to: " + str(dp_port)) testutils.ofmsg_send(self, msg) (of_port, pkt, _) = self.dataplane.poll(timeout=3) self.assertTrue(pkt is not None, 'Packet not received') basic_logger.info("PacketOut: got pkt from " + str(of_port)) if of_port is not None: self.assertEqual(of_port, dp_port, "Unexpected receive port") self.assertEqual(str(outpkt), str(pkt), 'Response packet does not match send packet')
def scenario3(self, first_table=0, second_table=1, third_table=2): """ Add three 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 TCP port B; send to 2 Then send in 2 packets: IP A, TCP C; expect out port 1 IP A, TCP B; expect out port 2 @param self object instance @param first_table first table @param second_table second table @param third_table third table """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up first match write_goto(self, first_table, second_table) # Set up second match write_goto_output(self, second_table, third_table, of_ports[0]) # Set up third match match = ofp.ofp_match() match.length = ofp.OFPMT_STANDARD_LENGTH testutils.wildcard_all_set(match) match.wildcards -= ofp.OFPFW_DL_TYPE match.wildcards -= ofp.OFPFW_TP_SRC match.dl_type = MT_TEST_DL_TYPE match.nw_proto = 6 #TCP match.tp_src = 80 write_output(self, third_table, of_ports[1], match=match) # Generate a packet matching only flow 1 and 2; rcv on port[0] reply_check_dp(self, tcp_sport=10, ing_port=of_ports[2], egr_port=of_ports[0]) # Generate a packet matching both flow 1, 2 and 3; rcv on port[1] reply_check_dp(self, tcp_sport=80, ing_port=of_ports[2], egr_port=of_ports[1])
def runTest(self): 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.EX_L3_TABLE) # Set up second match testutils.write_goto(self, testutils.WC_SERV_TABLE, testutils.EX_L2_TABLE, of_ports[2]) # Set up third match testutils.write_goto(self, testutils.EX_L2_TABLE, testutils.EX_L3_TABLE) # Set up fourth match testutils.write_output(self, testutils.EX_L3_TABLE, of_ports[1]) # 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 = testutils.clear_switch(self, basic_port_map.keys(), basic_logger) for max_len in [ 0, 99, DEFAULT_MISS_SEND_LEN, ofp.OFPCML_MAX, ofp.OFPCML_NO_BUFFER ]: rc = testutils.delete_all_flows(self.controller, basic_logger) self.assertEqual(rc, 0, "Failed to delete all flows") testutils.set_config_verify(self, max_len=(max_len % ofp.OFPCML_MAX + 10)) if max_len == ofp.OFPCML_NO_BUFFER: testutils.set_config_verify(self, max_len=max_len) request = message.flow_mod() request.table_id = 0 request.priority = 0 request.cookie = 123456 act = action.action_output() act.max_len = max_len act.port = ofp.OFPP_CONTROLLER inst_packet_in = instruction.instruction_apply_actions() #apply inst_packet_in.actions.add(act) request.instructions.add(inst_packet_in) rv = self.controller.message_send(request) for of_port in basic_port_map.keys(): basic_logger.info("PKT IN test, port " + str(of_port)) pkt = testutils.simple_tcp_packet() self.dataplane.send(of_port, str(pkt)) #@todo Check for unexpected messages? testutils.do_barrier(self.controller) #testutils.packetin_verify(self, pkt, max_len) response, _ = self.controller.poll(ofp.OFPT_PACKET_IN, 1) self.assertEqual(response.cookie, request.cookie, "cookie is not equal") #print(response.cookie) #print(request.cookie) #clear the msg response, _ = self.controller.poll(ofp.OFPT_PACKET_IN, 1) while response != None: response, _ = self.controller.poll(ofp.OFPT_PACKET_IN, 1)
def scenario4(self, first_table=0, second_table=1, third_table=2, fourth_table=3): """ 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; clear action, goto Fourth Table Fourth Table; Match IP Src A; send to 2 Then send in 2 packets: IP A, TCP C; expect out port 1 IP A, TCP B; expect out port 1 @param self object instance @param first_table first table @param second_table second table @param third_table third table @param fourth_table fourth table """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up first match write_goto(self, first_table, second_table) # Set up second match write_goto_output(self, second_table, third_table, of_ports[0]) # Set up third match, "Clear Action" inst = instruction.instruction_clear_actions() write_goto(self, third_table, fourth_table, add_inst=inst) # Set up fourth match write_output(self, fourth_table, of_ports[1]) # Generate a packet matching flow 1, 2, and 3; rcv on port[1] reply_check_dp(self, tcp_sport=10, ing_port=of_ports[2], egr_port=of_ports[1]) # Generate a packet matching flow 1, 2, and 3; rcv on port[1] reply_check_dp(self, tcp_sport=80, ing_port=of_ports[2], egr_port=of_ports[1])
def scenario4(self, first_table = 0, second_table = 1, third_table = 2, fourth_table = 3): """ 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 first_table first table @param second_table second table @param third_table third table @param fourth_table fourth table """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up first match write_goto_output(self, first_table, second_table, of_ports[0]) # Set up second match inst = instruction.instruction_write_metadata() inst.metadata = 0xfedcba9876543210 inst.metadata_mask = 0xffffffffffffffff write_goto(self, second_table, third_table, add_inst=inst) # Set up third match match = make_match() match.metadata = 0xfedcba9876543210 match.metadata_mask = 0xffffffffffffffff write_output(self, third_table, of_ports[1], match=match) # Set up fourth match write_output(self, fourth_table, of_ports[0]) # Generate a packet matching flow 1, 2, and 3; rcv on port[1] reply_check_dp(self, tcp_sport=10, ing_port = of_ports[2], egr_port = of_ports[1]) # Generate a packet matching flow 1, 2, and 3; rcv on port[1] reply_check_dp(self, tcp_sport=80, ing_port = of_ports[2], egr_port = of_ports[1])
def runTest(self): """ Add flow entries: First Table; Match IP Src A; set ToS = tos1, goto Second Table First Table; Match IP Src B; set ToS = tos2, goto Second Table Second Table; Match IP Src A; send to 1 Second Table; Match IP Src B; send to 1 Then send packets: IP A; expect port 1 with DSCP = dscp1 IP B; expect port 1 with DSCP = dscp2 @param self object instance @param EX_ACL_TABLE first table @param WC_ACL_TABLE second table @param dscp1 DSCP value to be set for first flow @param dscp2 DSCP value to be set for second flow """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up flow match in table A: set ToS #t_act = action.action_set_nw_tos() #t_act.nw_tos = tos1 dscp1 = 4 dscp2 = 8 t_act = action.action_set_field() t_act.field = match.ip_dscp(dscp1) testutils.write_goto_action(self, testutils.WC_ACL_TABLE, testutils.WC_ALL_TABLE, t_act, ip_src='192.168.1.10') t_act.field = match.ip_dscp(dscp2) #t_act.field = match.ip_ecn(3) testutils.write_goto_action(self, testutils.WC_ACL_TABLE, testutils.WC_ALL_TABLE, t_act, ip_src='192.168.1.30',clear_tag=False) # Set up flow matches in table B: routing testutils.write_output(self, testutils.WC_ALL_TABLE, of_ports[1], of_ports[2], ip_src="192.168.1.10") testutils.write_output(self, testutils.WC_ALL_TABLE, of_ports[1], of_ports[2], ip_src="192.168.1.30") # Generate packets and check them exp_pkt = testutils.simple_tcp_packet(ip_src='192.168.1.10', tcp_sport=1234, ip_dscp=dscp1) testutils.reply_check_dp(self, ip_src='192.168.1.10', tcp_sport=1234, exp_pkt=exp_pkt, ing_port=of_ports[2], egr_port=of_ports[1])
def scenario2(self, first_table = 0, second_table = 1, tos1 = 4, tos2 = 8): """ Add flow entries: First Table; Match IP Src A; set ToS = tos1, goto Second Table First Table; Match IP Src B; set ToS = tos2, goto Second Table Second Table; Match IP Src A; send to 1 Second Table; Match IP Src B; send to 1 Then send packets: IP A; expect port 1 with ToS = tos1 IP B; expect port 1 with ToS = tos2 @param self object instance @param first_table first table @param second_table second table @param tos1 ToS value to be set for first flow @param tos2 ToS value to be set for second flow """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up flow match in table A: set ToS t_act = action.action_set_nw_tos() t_act.nw_tos = tos1 write_goto_action(self, first_table, second_table, t_act, ip_src='192.168.1.10') t_act.nw_tos = tos2 write_goto_action(self, first_table, second_table, t_act, ip_src='192.168.1.30') # Set up flow matches in table B: routing write_output(self, second_table, of_ports[1], ip_src="192.168.1.10") write_output(self, second_table, of_ports[1], ip_src="192.168.1.30") # Generate packets and check them exp_pkt = testutils.simple_tcp_packet(ip_src='192.168.1.10', tcp_sport=10, ip_tos=tos1) reply_check_dp(self, ip_src='192.168.1.10', tcp_sport=10, exp_pkt=exp_pkt, ing_port=of_ports[2], egr_port=of_ports[1]) exp_pkt = testutils.simple_tcp_packet(ip_src='192.168.1.30', tcp_sport=10, ip_tos=tos2) reply_check_dp(self, ip_src='192.168.1.30', tcp_sport=10, exp_pkt=exp_pkt, ing_port=of_ports[2], egr_port=of_ports[1])
def runTest(self): # Construct packet to send to dataplane # Send packet to dataplane, once to each port # Poll controller with expect message type packet in of_ports = testutils.clear_switch(self, basic_port_map.keys(), basic_logger) testutils.set_table_config(self, 0, ofp.OFPTC_TABLE_MISS_CONTROLLER, True) #_,miss_send_len = testutils.get_config_reply_verify(self) testutils.set_config_verify(self, max_len = ofp.OFPCML_NO_BUFFER) for of_port in basic_port_map.keys(): basic_logger.info("PKT IN test, port " + str(of_port)) pkt = testutils.simple_tcp_packet() self.dataplane.send(of_port, str(pkt)) #@todo Check for unexpected messages? testutils.packetin_verify(self, pkt, ofp.OFPCML_NO_BUFFER) response,_ = self.controller.poll(ofp.OFPT_PACKET_IN, 1) while response != None: response,_ = self.controller.poll(ofp.OFPT_PACKET_IN, 1) testutils.set_config_verify(self, max_len = DEFAULT_MISS_SEND_LEN)
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 scenario3(self, first_table = 0, second_table = 1, third_table = 2): """ Add three 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 TCP port B; send to 2 Then send in 2 packets: IP A, TCP C; expect out port 1 IP A, TCP B; expect out port 2 @param self object instance @param first_table first table @param second_table second table @param third_table third table """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up first match write_goto(self, first_table, second_table) # Set up second match write_goto_output(self, second_table, third_table, of_ports[0]) # Set up third match match = ofp.ofp_match() match.length = ofp.OFPMT_STANDARD_LENGTH testutils.wildcard_all_set(match) match.wildcards -= ofp.OFPFW_DL_TYPE match.wildcards -= ofp.OFPFW_NW_PROTO match.wildcards -= ofp.OFPFW_TP_SRC match.dl_type = MT_TEST_DL_TYPE match.nw_proto = 6 #TCP match.tp_src = 80 write_output(self, third_table, of_ports[1], match=match) # Generate a packet matching only flow 1 and 2; rcv on port[0] reply_check_dp(self, tcp_sport=10, ing_port = of_ports[2], egr_port = of_ports[0]) # Generate a packet matching both flow 1, 2 and 3; rcv on port[1] reply_check_dp(self, tcp_sport=80, ing_port = of_ports[2], egr_port = of_ports[1])
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 = 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[1]) # Set up third match testutils.write_output(self, testutils.EX_L2_TABLE, of_ports[2]) # Generate a packet and receive 3 responses pkt = testutils.simple_tcp_packet(ip_src=testutils.MT_TEST_IP) self.dataplane.send(of_ports[1], str(pkt)) testutils.receive_pkt_verify(self, of_ports[2], pkt)
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 = testutils.clear_switch(self, basic_port_map.keys(), basic_logger) for max_len in [0, 99, DEFAULT_MISS_SEND_LEN, ofp.OFPCML_MAX, ofp.OFPCML_NO_BUFFER]: rc = testutils.delete_all_flows(self.controller, basic_logger) self.assertEqual(rc, 0, "Failed to delete all flows") testutils.set_config_verify(self, max_len = (max_len % ofp.OFPCML_MAX + 10)) if max_len == ofp.OFPCML_NO_BUFFER: testutils.set_config_verify(self, max_len = max_len) testutils.set_flow_miss_entry(self, ofp.OFPTC_TABLE_MISS_CONTROLLER, max_len, 0) for of_port in basic_port_map.keys(): basic_logger.info("PKT IN test, port " + str(of_port)) pkt = testutils.simple_tcp_packet() self.dataplane.send(of_port, str(pkt)) #@todo Check for unexpected messages? testutils.do_barrier(self.controller) testutils.packetin_verify(self, pkt, max_len) response,_ = self.controller.poll(ofp.OFPT_PACKET_IN, 1) while response != None: response,_ = self.controller.poll(ofp.OFPT_PACKET_IN, 1) testutils.set_config_verify(self, max_len = DEFAULT_MISS_SEND_LEN)
def runTest(self): # Construct packet to send to dataplane # Send packet to dataplane, once to each port # Poll controller with expect message type packet in of_ports = testutils.clear_switch(self, basic_port_map.keys(), basic_logger) testutils.set_table_config(self, 0, ofp.OFPTC_TABLE_MISS_CONTROLLER, True) #_,miss_send_len = testutils.get_config_reply_verify(self) testutils.set_config_verify(self, max_len=ofp.OFPCML_NO_BUFFER) for of_port in basic_port_map.keys(): basic_logger.info("PKT IN test, port " + str(of_port)) pkt = testutils.simple_tcp_packet() self.dataplane.send(of_port, str(pkt)) #@todo Check for unexpected messages? testutils.packetin_verify(self, pkt, ofp.OFPCML_NO_BUFFER) response, _ = self.controller.poll(ofp.OFPT_PACKET_IN, 1) while response != None: response, _ = self.controller.poll(ofp.OFPT_PACKET_IN, 1) testutils.set_config_verify(self, max_len=DEFAULT_MISS_SEND_LEN)
def scenario2(self, first_table = 0, second_table = 1): """ Set table config as "Continue" and add flow entry: First Table; Match IP Src A; send to 1 // not match then continue Second Table; Match IP Src B; send to 2 // do execution Then send in 2 packets: IP B; expect out port 2 """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set table config as "continue" setup_table_config(self, first_table, ofp.OFPTC_TABLE_MISS_CONTINUE) # Set up flow entries write_output(self, first_table, of_ports[0], ip_src="192.168.1.10") write_output(self, second_table, of_ports[1], ip_src="192.168.1.70") # Generate a packet not matching in the first table, but in the second reply_check_dp(self, ip_src='192.168.1.70', tcp_sport=10, ing_port = of_ports[2], egr_port = of_ports[1])
def runTest(self): """ 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 @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(self, testutils.EX_ACL_TABLE, testutils.WC_ACL_TABLE) # Set up second match testutils.write_goto_output(self, testutils.WC_ACL_TABLE, testutils.WC_SERV_TABLE, of_ports[0]) # Set up third match testutils.write_output(self, testutils.WC_SERV_TABLE, of_ports[1], of_ports[2]) # 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[1])
def runTest(self): """ 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; clear action, goto Fourth Table Fourth Table; Match IP Src A; send to 2 Then send in 2 packets: IP A, TCP C; expect out port 1 IP A, TCP B; expect out port 1 @param self object instance @param EX_ACL_TABLE first table @param WC_ACL_TABLE second table @param WC_SERV_TABLE third table @param EX_L2_TABLE fourth table """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set up first match #write_goto(self, testutils.EX_ACL_TABLE, testutils.WC_ACL_TABLE) act = action.action_set_field() field = match.eth_src(parse.parse_mac("aa:aa:aa:aa:aa:aa")) act.field.add(field) testutils.write_goto_action(self, testutils.WC_ACL_TABLE, testutils.WC_SERV_TABLE ,act = act) # Set up second match testutils.write_goto_output(self, testutils.WC_SERV_TABLE, testutils.EX_L3_TABLE, of_ports[0], of_ports[2]) # Set up third match, "Clear Action" inst = instruction.instruction_clear_actions() testutils.write_goto(self, testutils.EX_L3_TABLE, testutils.WC_L3_TABLE, of_ports[2], add_inst=inst) # Set up fourth match testutils.write_output(self, testutils.WC_L3_TABLE, of_ports[1]) #write_output(self, testutils.EX_L2_TABLE, 4) # 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 scenario2(self, first_table = 0, second_table = 1): """ Set the first table config as "Send to Controller" and the second table as "Drop", add flow entries: First Table; Match IP Src A; send to 1 // if not match, packet_in Second Table; Match IP Src B; send to 2 // if not match, drop Then send a packet: IP B; expect packet_in """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set table config as "send to controller" and "drop" setup_table_config(self, first_table, ofp.OFPTC_TABLE_MISS_CONTROLLER) setup_table_config(self, second_table, ofp.OFPTC_TABLE_MISS_DROP) # Set up matches write_output(self, first_table, of_ports[0], ip_src="192.168.1.10") write_output(self, second_table, of_ports[1], ip_src="192.168.1.70") # Generate a packet not matching to any flow entry in the first table reply_check_ctrl(self, ip_src='192.168.1.70', tcp_sport=10, ing_port = of_ports[2])
def runTest(self): 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.EX_L3_TABLE) # Set up second match testutils.write_goto(self, testutils.WC_SERV_TABLE, testutils.EX_L2_TABLE, of_ports[2]) # Set up third match testutils.write_goto(self, testutils.EX_L2_TABLE, testutils.EX_L3_TABLE) # Set up fourth match testutils.write_output(self, testutils.EX_L3_TABLE, of_ports[1]) # 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 = testutils.clear_switch(self, basic_port_map.keys(), basic_logger) for max_len in [0, 99, DEFAULT_MISS_SEND_LEN, ofp.OFPCML_MAX, ofp.OFPCML_NO_BUFFER]: rc = testutils.delete_all_flows(self.controller, basic_logger) self.assertEqual(rc, 0, "Failed to delete all flows") testutils.set_config_verify(self, max_len = (max_len % ofp.OFPCML_MAX + 10)) if max_len == ofp.OFPCML_NO_BUFFER: testutils.set_config_verify(self, max_len = max_len) request = message.flow_mod() request.table_id = 0 request.priority = 0 request.cookie = 123456 act = action.action_output() act.max_len = max_len act.port = ofp.OFPP_CONTROLLER inst_packet_in = instruction.instruction_apply_actions()#apply inst_packet_in.actions.add(act) request.instructions.add(inst_packet_in) rv = self.controller.message_send(request) for of_port in basic_port_map.keys(): basic_logger.info("PKT IN test, port " + str(of_port)) pkt = testutils.simple_tcp_packet() self.dataplane.send(of_port, str(pkt)) #@todo Check for unexpected messages? testutils.do_barrier(self.controller) #testutils.packetin_verify(self, pkt, max_len) response,_ = self.controller.poll(ofp.OFPT_PACKET_IN, 1) self.assertEqual(response.cookie, request.cookie, "cookie is not equal") #print(response.cookie) #print(request.cookie) #clear the msg response,_ = self.controller.poll(ofp.OFPT_PACKET_IN, 1) while response != None: response,_ = self.controller.poll(ofp.OFPT_PACKET_IN, 1)
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 scenario2(self, first_table=0, second_table=1): """ Set table config as "Continue" and add flow entry: First Table; Match IP Src A; send to 1 // not match then continue Second Table; Match IP Src B; send to 2 // do execution Then send in 2 packets: IP B; expect out port 2 """ of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) # Set table config as "continue" setup_table_config(self, first_table, ofp.OFPTC_TABLE_MISS_CONTINUE) # Set up flow entries write_output(self, first_table, of_ports[0], ip_src="192.168.1.10") write_output(self, second_table, of_ports[1], ip_src="192.168.1.70") # Generate a packet not matching in the first table, but in the second reply_check_dp(self, ip_src='192.168.1.70', tcp_sport=10, ing_port=of_ports[2], egr_port=of_ports[1])
def runTest(self): of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger) mpls_multipush2_act_tests(self, test_condition=3)