def runTest(self): self.clear_switch() group_add_msg2 = \ create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 2, buckets = [ create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_SET_TP_SRC, tp_port = 2000), create_action(action = ofp.OFPAT_OUTPUT, port = 2) ]) ]) self.send_ctrl_exp_noerror(group_add_msg2, 'group add') group_add_msg1 = \ create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 1, buckets = [ create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_GROUP, group_id = 2), ]) ]) self.send_ctrl_exp_noerror(group_add_msg1, 'group add') packet_in = testutils.simple_tcp_packet(tcp_sport=1000) packet_out = testutils.simple_tcp_packet(tcp_sport=2000) flow_add_msg = \ create_flow_msg(packet = packet_in, in_port = 1, apply_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): 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_TP_SRC, tp_port = 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 = \ create_flow_msg(packet = packet_in, in_port = 1, apply_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): self.clear_switch() group_add_msg2 = \ create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 2, buckets = [ create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 2000), create_action(action = ofp.OFPAT_OUTPUT, port = 2) ]) ]) self.send_ctrl_exp_noerror(group_add_msg2, 'group add') group_add_msg1 = \ create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 1, buckets = [ create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_GROUP, group_id = 2), ]) ]) self.send_ctrl_exp_noerror(group_add_msg1, '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): of_ports = pa_port_map.keys() of_ports.sort() ing_port = of_ports[0] egr_port = of_ports[3] # Remove all entries Add entry match all rc = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rc, 0, "Failed to delete all flows") # Add entry match all flow_match = "wildcards=none,dl_src_mask=ff:ff:ff:ff:ff:ff,dl_dst_mask=ff:ff:ff:ff:ff:ff,nw_src_mask=255.255.255.255,nw_dst_mask=255.255.255.255,meta_mask=0xffffffffffffffff" #, -in_port,in_port=1,dl_type=2048in_port=0 wildcards=0xffff flow_acts = "apply:output=" + str(egr_port) rc = nxm_send_flow_mod_add(flow_match,flow_acts,pa_logger) self.assertEqual(rc, 0, "Failed to add flow entry") #Send packet pkt = testutils.simple_tcp_packet() pa_logger.info("Sending IPv4 packet to " + str(ing_port)) pa_logger.debug("Data: " + str(pkt).encode('hex')) self.dataplane.send(ing_port, str(pkt)) #Receive packet exp_pkt = testutils.simple_tcp_packet() testutils.receive_pkt_verify(self, egr_port, exp_pkt) #See flow match request_flow_stats() #Remove flows #rc = testutils.delete_all_flows(self.controller, pa_logger) rc = nxm_delete_all_flows() self.assertEqual(rc, 0, "Failed to delete all flows")
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): 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 = pa_port_map.keys() of_ports.sort() ing_port = of_ports[0] egr_port = of_ports[3] # Remove all entries Add entry match all rc = dpctl.oxm_delete_all_flows() self.assertEqual(rc, 0, "Failed to delete all flows") # Add entry match all flow_match = "dl_type=0x0800,nw_src=192.168.0.1" flow_acts = "apply:output=" + str(egr_port) rc = dpctl.oxm_send_flow_mod_add(flow_match,flow_acts,pa_logger) self.assertEqual(rc, 0, "Failed to add flow entry") #Send packet pkt = testutils.simple_tcp_packet() pa_logger.info("Sending IPv4 packet to " + str(ing_port)) pa_logger.debug("Data: " + str(pkt).encode('hex')) self.dataplane.send(ing_port, str(pkt)) #Receive packet exp_pkt = testutils.simple_tcp_packet() testutils.receive_pkt_verify(self, egr_port, exp_pkt) #See flow match dpctl.request_flow_stats() #Remove flows rc = dpctl.oxm_delete_all_flows() self.assertEqual(rc, 0, "Failed to delete all flows")
def runTest(self): # Config of_ports = pa_port_map.keys() of_ports.sort() ing_port = of_ports[0] egr_port = of_ports[1] rc = dpctl.oxm_delete_all_flows() self.assertEqual(rc, 0, "Failed to delete all flows") flow_match = "in_port=" + str(ing_port) flow_acts = "apply:output=" + str(egr_port) rc = dpctl.oxm_send_flow_mod_add(flow_match,flow_acts,pa_logger) self.assertEqual(rc, 0, "Failed to add flow entry") pkt = testutils.simple_tcp_packet() pa_logger.info("Sending IPv4 packet to " + str(ing_port)) pa_logger.debug("Data: " + str(pkt).encode('hex')) pkt = testutils.simple_tcp_packet() pa_logger.info("Sending IPv4 packet to " + str(ing_port)) pa_logger.debug("Data: " + str(pkt).encode('hex')) self.dataplane.send(ing_port, str(pkt)) exp_pkt = testutils.simple_tcp_packet() testutils.receive_pkt_verify(self, egr_port, exp_pkt) #See flow match dpctl.request_flow_stats() rc = dpctl.oxm_delete_all_flows() self.assertEqual(rc, 0, "Failed to delete all flows")
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): #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): 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() group_add_msg2 = \ create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 2, buckets = [ create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 2000), create_action(action = ofp.OFPAT_OUTPUT, port = 2) ]) ]) self.send_ctrl_exp_noerror(group_add_msg2, 'group add 2') group_add_msg3 = \ create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 3, buckets = [ create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 3000), create_action(action = ofp.OFPAT_OUTPUT, port = 3) ]), create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 4000), create_action(action = ofp.OFPAT_OUTPUT, port = 4) ]) ]) self.send_ctrl_exp_noerror(group_add_msg3, 'group add 3') group_add_msg1 = \ create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 1, buckets = [ create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_GROUP, group_id = 2), ]), create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_GROUP, group_id = 3), ]) ]) self.send_ctrl_exp_noerror(group_add_msg1, 'group add 1') packet_in = testutils.simple_tcp_packet(tcp_sport=1000) packet_out1 = testutils.simple_tcp_packet(tcp_sport=2000) packet_out2 = testutils.simple_tcp_packet(tcp_sport=3000) packet_out3 = testutils.simple_tcp_packet(tcp_sport=4000) flow_add_msg = \ testutils.flow_msg_create(self,packet_in,ing_port = 1,action_list = [ create_action(action = ofp.OFPAT_GROUP, group_id = 1) ]) self.send_ctrl_exp_noerror(flow_add_msg, 'flow add') self.send_data(packet_in, 1) self.recv_data(2, packet_out1) self.recv_data(3, packet_out2) self.recv_data(4, packet_out3)
def runTest(self): self.clear_switch() group_add_msg2 = \ create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 2, buckets = [ create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_SET_TP_SRC, tp_port = 2000), create_action(action = ofp.OFPAT_OUTPUT, port = 2) ]) ]) self.send_ctrl_exp_noerror(group_add_msg2, 'group add 2') group_add_msg3 = \ create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 3, buckets = [ create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_SET_TP_SRC, tp_port = 3000), create_action(action = ofp.OFPAT_OUTPUT, port = 3) ]), create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_SET_TP_SRC, tp_port = 4000), create_action(action = ofp.OFPAT_OUTPUT, port = 4) ]) ]) self.send_ctrl_exp_noerror(group_add_msg3, 'group add 3') group_add_msg1 = \ create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 1, buckets = [ create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_GROUP, group_id = 2), ]), create_bucket(0, 0, 0, [ create_action(action = ofp.OFPAT_GROUP, group_id = 3), ]) ]) self.send_ctrl_exp_noerror(group_add_msg1, 'group add 1') packet_in = testutils.simple_tcp_packet(tcp_sport=1000) packet_out1 = testutils.simple_tcp_packet(tcp_sport=2000) packet_out2 = testutils.simple_tcp_packet(tcp_sport=3000) packet_out3 = testutils.simple_tcp_packet(tcp_sport=4000) flow_add_msg = \ create_flow_msg(packet = packet_in, in_port = 1, apply_action_list = [ create_action(action = ofp.OFPAT_GROUP, group_id = 1), ]) self.send_ctrl_exp_noerror(flow_add_msg, 'flow add') self.send_data(packet_in, 1) self.recv_data(2, packet_out1) self.recv_data(3, packet_out2) self.recv_data(4, packet_out3)
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 2, "Not enough ports for test") # For making the test simpler... ing_port = of_ports[0] egr_port = of_ports[1] pktlen = 104 dl_vlan = 0xa5a # no specific meaning dl_vlan_pcp=3 pkt = testutils.simple_tcp_packet(pktlen=pktlen, dl_vlan_enable=True, dl_vlan=dl_vlan, dl_vlan_pcp=dl_vlan_pcp) match = parse.packet_to_flow_match(pkt) wildcards = 0 exp_pkt = testutils.simple_tcp_packet(pktlen=pktlen, dl_vlan_enable=True) # Create parameters for each table act_list = [] next_avail = [] chk_expire = [] #Table 0 act = action.action_output() act.port = egr_port act_list.append([act]) next_avail.append(True) chk_expire.append(False) #Table 1 act = action.action_push_vlan() act.ethertype = ETHERTYPE_VLAN act_list.append([act]) next_avail.append(True) chk_expire.append(False) #Table 2 act = action.action_pop_vlan() act_list.append([act]) next_avail.append(False) chk_expire.append(False) write_action_test_multi_tables(self, ing_port, egr_port, match = match, wildcards = wildcards, act_list = act_list, next_avail = next_avail, chk_expire = chk_expire, pkt = pkt, exp_pkt = exp_pkt)
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 2, "Not enough ports for test") # For making the test simpler... ing_port = of_ports[0] egr_port = of_ports[1] dl_vlan = random.randint(1,0x7ff) dl_vlan_pcp = random.randint(0,7) pkt = testutils.simple_tcp_packet(vlan_tags=[{'vid': dl_vlan, 'pcp': dl_vlan_pcp}]) match_ls = parse.packet_to_flow_match(pkt) wildcards = 0 new_dl_vlan = random.randint(0x800,0xfff) exp_pkt = testutils.simple_tcp_packet(vlan_tags=[{'type': ETHERTYPE_VLAN, 'vid': new_dl_vlan, 'pcp': dl_vlan_pcp}, {'vid': dl_vlan, 'pcp': dl_vlan_pcp}]) # Create parameters for each table act_list = [] next_avail = [] chk_expire = [] #Table 0 act = action.action_output() act.port = egr_port act_list.append([act]) next_avail.append(True) chk_expire.append(False) #Table 1 #act = action.action_set_vlan_vid() #act.vlan_vid = new_dl_vlan act = action.action_set_field() act.field = match.vlan_vid(new_dl_vlan + ofp.OFPVID_PRESENT) act_list.append([act]) next_avail.append(True) chk_expire.append(False) #Table 2 act = action.action_push_vlan() act.ethertype = ETHERTYPE_VLAN act_list.append([act]) next_avail.append(False) chk_expire.append(False) write_action_test_multi_tables(self, ing_port, egr_port, match_fields = match_ls, wildcards = wildcards, act_list = act_list, next_avail = next_avail, chk_expire = chk_expire, pkt = pkt, exp_pkt = exp_pkt)
def runTest(self): old_vid = 2 #sup_acts = supported_actions_get(self) #if not (sup_acts & 1 << ofp.OFPAT_POP_VLAN): #testutils.skip_message_emit(self, "Strip VLAN tag test") #return pkt = testutils.simple_tcp_packet(vlan_tags=[{'vid': old_vid}]) exp_pkt = testutils.simple_tcp_packet() vid_act = action.action_pop_vlan() testutils.flow_match_test(self, pa_port_map,pkt=pkt, exp_pkt=exp_pkt, apply_action_list=[vid_act] , max_test = 10)
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): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 2, "Not enough ports for test") # For making the test simpler... ing_port = of_ports[0] egr_port = of_ports[1] dl_vlan = 0xa5a # no specific meaning dl_vlan_pcp=3 outer_dl_vlan = 0x18F pkt = testutils.simple_tcp_packet(vlan_tags=[{'type' : ETHERTYPE_VLAN, 'vid': outer_dl_vlan}, {'vid': dl_vlan, 'pcp': dl_vlan_pcp}]) match = parse.packet_to_flow_match(pkt) wildcards = 0 new_dl_vlan = 0xfed exp_pkt = testutils.simple_tcp_packet(vlan_tags=[{'vid': new_dl_vlan, 'pcp': dl_vlan_pcp}]) # Create parameters for each table act_list = [] next_avail = [] chk_expire = [] #Table 0 act = action.action_output() act.port = egr_port act_list.append([act]) next_avail.append(True) chk_expire.append(False) #Table 1 act = action.action_set_vlan_vid() act.vlan_vid = new_dl_vlan act_list.append([act]) next_avail.append(True) chk_expire.append(False) #Table 2 act = action.action_pop_vlan() act_list.append([act]) next_avail.append(False) chk_expire.append(False) write_action_test_multi_tables(self, ing_port, egr_port, match = match, wildcards = wildcards, act_list = act_list, next_avail = next_avail, chk_expire = chk_expire, pkt = pkt, exp_pkt = exp_pkt)
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() ing_port = of_ports[0] egr_port = of_ports[2] self.of_dir = os.path.normpath("../../of11softswitch") self.ofd = os.path.normpath(self.of_dir + "/udatapath/ofdatapath") self.dpctl = os.path.normpath(self.of_dir + "/utilities/dpctl") dpctl_switch = "unix:/tmp/ofd" # Remove all entries Add entry match all # sudo ./dpctl unix:/tmp/ofd flow-mod cmd=del,table=0 # flow_cmd1 = "flow-mod" # flow_cmd2 = "cmd=del,table=0" # pcall = [self.dpctl, dpctl_switch, flow_cmd1, flow_cmd2] # subprocess.call(pcall) rc = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rc, 0, "Failed to delete all flows") # Add entry match all flow_cmd1 = "flow-mod" flow_cmd2 = "cmd=add,table=0,idle=100" flow_match = "wildcards=+all,dl_src_mask=FF:FF:FF:FF:FF:FF,dl_dst_mask=FF:FF:FF:FF:FF:FF,nw_src_mask=255.255.255.255,nw_dst_mask=255.255.255.255" #, -in_port,in_port=1,dl_type=2048in_port=0 wildcards=0xffff flow_acts = "apply:output=" + str(egr_port) pcall = [self.dpctl, dpctl_switch, flow_cmd1, flow_cmd2, flow_match, flow_acts] print pcall subprocess.call(pcall) #Send packet pkt = testutils.simple_tcp_packet() pa_logger.info("Sending IPv4 packet to " + str(ing_port)) pa_logger.debug("Data: " + str(pkt).encode('hex')) self.dataplane.send(ing_port, str(pkt)) #Receive packet exp_pkt = testutils.simple_tcp_packet() testutils.receive_pkt_verify(self, egr_port, exp_pkt) #See flow match pa_logger.debug("Request stats-flow") pcall = [self.dpctl, dpctl_switch, "stats-flow"] # subprocess.call(pcall) #Remove flows rc = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rc, 0, "Failed to delete all flows")
def runTest(self): old_vid = 2 new_vid = 3 # sup_acts = supported_actions_get(self) # if not (sup_acts & 1 << ofp.OFPXMT_OFB_VLAN_VID): # testutils.skip_message_emit(self, "Modify VLAN tag test") # return pkt = testutils.simple_tcp_packet(vlan_tags=[{'vid': old_vid}]) exp_pkt = testutils.simple_tcp_packet(vlan_tags=[{'vid': new_vid}]) vid_act = action.action_set_field() vid_act.field = match.vlan_vid(new_vid + ofp.OFPVID_PRESENT) testutils.flow_match_test(self, pa_port_map, pkt=pkt, exp_pkt=exp_pkt, apply_action_list=[vid_act])
def runTest(self): old_vid = 2 new_vid = 3 sup_acts = supported_actions_get(self) if not (sup_acts & 1 << ofp.OFPAT_SET_VLAN_VID): testutils.skip_message_emit(self, "Modify VLAN tag test") return pkt = testutils.simple_tcp_packet(vlan_tags=[{'vid': old_vid}]) exp_pkt = testutils.simple_tcp_packet(vlan_tags=[{'vid': new_vid}]) vid_act = action.action_set_vlan_vid() vid_act.vlan_vid = new_vid testutils.flow_match_test(self, pa_port_map, pkt=pkt, exp_pkt=exp_pkt, apply_action_list=[vid_act])
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") pkt = testutils.simple_tcp_packet() for ingress_port in of_ports: rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") pa_logger.info("Ingress " + str(ingress_port) + " to all ports") request = testutils.flow_msg_create(self, pkt, ing_port=ingress_port, egr_port=ofp.OFPP_ALL) pa_logger.info("Inserting flow") testutils.ofmsg_send(self, request) pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) yes_ports = set(of_ports).difference([ingress_port]) testutils.receive_pkt_check(self.dataplane, pkt, yes_ports, [ingress_port], self, pa_logger)
def runTest(self): ing_port = flow_mods_port_map.keys()[0] out_port1 = flow_mods_port_map.keys()[1] out_port2 = flow_mods_port_map.keys()[2] pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) fm_orig = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port1) fm_new = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port2) fm_new.command = ofp.OFPFC_MODIFY_STRICT rv = self.controller.message_send(fm_orig) self.assertEqual(rv, 0, "Failed to insert 1st flow_mod") testutils.do_barrier(self.controller) rv = self.controller.message_send(fm_new) testutils.do_barrier(self.controller) self.assertEqual(rv, 0, "Failed to insert 2nd flow_mod") flow_stats = testutils.flow_stats_get(self) self.assertEqual(len(flow_stats.stats),1, "Expected only one flow_mod") stat = flow_stats.stats[0] self.assertEqual(stat.match, fm_new.match) self.assertEqual(stat.instructions, fm_new.instructions)
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 2, "Not enough ports for test") pkt = testutils.simple_tcp_packet() for ingress_port in of_ports: rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") pa_logger.info("Ingress " + str(ingress_port) + " to all ports") actions = [] for egress_port in of_ports: act = action.action_output() if egress_port == ingress_port: act.port = ofp.OFPP_IN_PORT else: act.port = egress_port actions.append(act) request = testutils.flow_msg_create(self, pkt, ingress_port, action_list=actions) request.buffer_id = 0xffffffff # pa_logger.info(request.show()) pa_logger.info("Inserting flow") rv = self.controller.message_send(request) self.assertTrue(rv != -1, "Error installing flow mod") testutils.do_barrier(self.controller) pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) testutils.receive_pkt_check(self.dataplane, pkt, of_ports, [], self, pa_logger)
def runTest(self): table_id = testutils.EX_L2_TABLE of_ports = exact_port_map.keys() egr_port = of_ports[1] pkt = testutils.simple_tcp_packet(dl_src='08:02:ff:34:88:99', dl_dst='22:22:ed:22:5f:1a') request = testutils.flow_msg_create(self, pkt, egr_port=egr_port, table_id=table_id) for obj in request.match_fields.tlvs: if obj.field == ofp.OFPXMT_OFB_METADATA: obj.value = 0x9922334455667788 request.idle_timeout = 1 request.flags |= ofp.OFPFF_SEND_FLOW_REM testutils.flow_msg_install(self, request) #print(request.show()) (response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 3) self.assertTrue(response is not None, 'Did not receive flow removed message ') self.assertEqual(request.cookie, response.cookie, 'Cookies do not match') self.assertEqual( ofp.OFPRR_IDLE_TIMEOUT, response.reason, 'Flow table entry removal reason is not idle_timeout')
def runTest(self): ing_port = flow_mods_port_map.keys()[0] out_port1 = ofp.OFPP_ALL pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) fm_orig = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port1)#flood inst = None inst = instruction.instruction_apply_actions() act = action.action_output() act.port = ofp.OFPP_IN_PORT #fwd to ingress rv = inst.actions.add(act) self.assertTrue(rv, "Could not add action" + act.show()) fm_orig.instructions.add(inst) #print(fm_orig.show()) testutils.ofmsg_send(self, fm_orig) (response, raw) = self.controller.poll(ofp.OFPT_ERROR, 2) self.assertTrue(response is None, 'Receive error message') #user sends packet self.dataplane.send(ing_port, str(pkt)) testutils.do_barrier(self.controller) #verify pkt for of_port in flow_mods_port_map.keys(): testutils.receive_pkt_verify(self, of_port, pkt)
def runTest(self): of_ports = 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): ing_port = flow_mods_port_map.keys()[0] out_port1 = flow_mods_port_map.keys()[1] out_port2 = flow_mods_port_map.keys()[2] pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) fm_orig = testutils.flow_msg_create(self, pkt, ing_port=ofp.OFPP_ANY, egr_port=out_port1, table_id=2) fm_new = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port2, table_id=2) fm_new.command = ofp.OFPFC_MODIFY_STRICT testutils.ofmsg_send(self, fm_orig) testutils.ofmsg_send(self, fm_new) flow_stats = testutils.flow_stats_get(self) #print(flow_stats.show()) self.assertEqual(len(flow_stats.stats), 1, "Expected only one flow_mod") #fail to modify and instruction will remain the same stat = flow_stats.stats[0] self.assertEqual(stat.match, fm_orig.match) self.assertEqual(stat.instructions, fm_orig.instructions)
def 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 runTest(self): for of_port in sdn_port_map.keys(): ing_port = of_port for egr_port in sdn_port_map.keys(): if egr_port != of_port: break #egr_port = (i+1) %4 + 1 #print("\ncount: " + str(ing_port)) #print("erg_port : " + str(egr_port) + " ing_port: " + str(ing_port)) self.logger.info("\ncount: " + str(ing_port)) self.logger.info("erg_port : " + str(egr_port) + " ing_port: " + str(ing_port)) pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) request = testutils.flow_msg_create(self, pkt, ing_port = ing_port, egr_port = egr_port,check_expire=True) request.cookie = random.randint(0,9007199254740992) request.buffer_id = 0xffffffff request.hard_timeout = 1000 request.idle_timeout = 1000 rv = self.controller.message_send(request) self.assertTrue(rv != -1, "Error installing flow mod") testutils.do_barrier(self.controller) self.dataplane.send(ing_port, str(pkt)) (rcv_port, rcv_pkt, _) = self.dataplane.poll(timeout=1) #print("erg_port : " + str(rcv_port) + " pkt: %s" % str(rcv_pkt).encode("hex") ) #print("\n") self.logger.info("erg_port : " + str(rcv_port) + " pkt: %s" % str(rcv_pkt).encode("hex") ) self.logger.info("\n") self.assertTrue(rcv_pkt is not None, "Did not receive packet")
def runTest(self): ing_port = sdn_port_map.keys()[0] for i in range(1, 1024*1000 + 1): #print("packet count:", i) self.logger.info("packet count:", i) pkt_send = testutils.simple_tcp_packet(dl_dst='11:22:33:44:55:66',tcp_sport = i % 5000 + 1000) num = self.dataplane.send(ing_port, str(pkt_send))
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): 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): table_id = testutils.EX_L2_TABLE of_ports = exact_port_map.keys() egr_port = of_ports[len(of_ports) - 1] pkt = testutils.simple_tcp_packet(dl_src='00:22:44:62:9b:1c', dl_dst='00:13:07:5f:61:ab') pkt_metadata = { 'metadata_val': 0xaa22334455667788, 'metadata_msk': 0xFFFFFFFFFFFFFFFF } request = testutils.flow_msg_create(self, pkt, pkt_metadata, egr_port=egr_port, table_id=table_id) request.hard_timeout = 8 request.idle_timeout = 8 testutils.flow_msg_install(self, request) #"get flow stats" stat_req = message.flow_stats_request() stat_req.buffer_id = 0xffffffff stat_req.table_id = table_id stat_req.out_port = ofp.OFPP_ANY stat_req.out_group = ofp.OFPG_ANY stat_req.match_fields = request.match_fields response, _ = self.controller.transact(stat_req, timeout=2) self.assertTrue(isinstance(response, message.flow_stats_reply), "Not a flow_stats_reply") self.assertEqual(len(response.stats), 1, "len of stats is:" + str(len(response.stats)))
def runTest(self): old_vid = 2 #sup_acts = supported_actions_get(self) #if not (sup_acts & 1 << ofp.OFPAT_POP_VLAN): #testutils.skip_message_emit(self, "Strip VLAN tag test") #return pkt = testutils.simple_tcp_packet(vlan_tags=[{'vid': old_vid}]) exp_pkt = testutils.simple_tcp_packet() vid_act = action.action_pop_vlan() testutils.flow_match_test(self, pa_port_map, pkt=pkt, exp_pkt=exp_pkt, apply_action_list=[vid_act], max_test=10)
def runTest(self): ing_port = flow_mods_port_map.keys()[0] out_port1 = flow_mods_port_map.keys()[1] out_port2 = flow_mods_port_map.keys()[2] pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) fm_orig = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port1) inst = None inst = instruction.instruction_write_actions( ) #instruct is the same, action is different act = action.action_output() act.port = out_port2 rv = inst.actions.add(act) self.assertTrue(rv, "Could not add action" + act.show()) fm_orig.instructions.add(inst) #print(fm_orig.show()) testutils.ofmsg_send(self, fm_orig) (response, raw) = self.controller.poll(ofp.OFPT_ERROR, 5) self.assertTrue(response is not None, 'No error message received') self.assertEqual( ofp.OFPET_BAD_INSTRUCTION, response.type, 'Error message type mismatch: ' + str(ofp.OFPET_BAD_INSTRUCTION, ) + " != " + str(response.type)) self.assertEqual( ofp.OFPBIC_UNKNOWN_INST, response.code, 'Error message code mismatch: ' + str(ofp.OFPBIC_UNKNOWN_INST) + " != " + str(response.code))
def runTest(self): 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): ing_port = flow_mods_port_map.keys()[0] out_port1 = flow_mods_port_map.keys()[1] out_port2 = flow_mods_port_map.keys()[2] pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) fm_orig = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port1) inst = None inst = instruction.instruction_write_actions()#instruct is the same, action is different act = action.action_output() act.port = out_port2 rv = inst.actions.add(act) self.assertTrue(rv, "Could not add action" + act.show()) fm_orig.instructions.add(inst) #print(fm_orig.show()) testutils.ofmsg_send(self, fm_orig) (response, raw) = self.controller.poll(ofp.OFPT_ERROR, 5) self.assertTrue(response is not None, 'No error message received') self.assertEqual(ofp.OFPET_BAD_INSTRUCTION, response.type, 'Error message type mismatch: ' + str(ofp.OFPET_BAD_INSTRUCTION,) + " != " + str(response.type)) self.assertEqual(ofp.OFPBIC_UNKNOWN_INST, response.code, 'Error message code mismatch: ' + str(ofp.OFPBIC_UNKNOWN_INST) + " != " + str(response.code))
def runTest(self): # Construct packet to send to dataplane # Send packet to dataplane, once to each port # Poll controller with expect message type packet in rc = testutils.delete_all_flows(self.controller, basic_logger) self.assertEqual(rc, 0, "Failed to delete all flows") 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? (response, _) = self.controller.poll(ofp.OFPT_PACKET_IN, 2) self.assertTrue( response is not None, 'Packet in message not received on port ' + str(of_port)) if str(pkt) != response.data: basic_logger.debug("pkt len " + str(len(str(pkt))) + ": " + str(pkt)) basic_logger.debug("resp len " + str(len(str(response.data))) + ": " + str(response.data)) self.assertEqual( str(pkt), response.data, 'Response packet does not match send packet' + ' for port ' + str(of_port))
def runTest(self): ing_port = flow_mods_port_map.keys()[0] out_port1 = flow_mods_port_map.keys()[1] out_port2 = flow_mods_port_map.keys()[2] pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) fm_orig = testutils.flow_msg_create(self, pkt, ing_port=ofp.OFPP_ANY, egr_port=out_port1, table_id=2) fm_new = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port2, table_id=2) fm_new.command = ofp.OFPFC_MODIFY_STRICT testutils.ofmsg_send(self, fm_orig) testutils.ofmsg_send(self, fm_new) flow_stats = testutils.flow_stats_get(self) #print(flow_stats.show()) self.assertEqual(len(flow_stats.stats),1, "Expected only one flow_mod") #fail to modify and instruction will remain the same stat = flow_stats.stats[0] self.assertEqual(stat.match, fm_orig.match) self.assertEqual(stat.instructions, fm_orig.instructions)
def runTest(self): # Construct packet to send to dataplane # Send packet to dataplane # Poll controller with expect message type packet in rc = testutils.delete_all_flows(self.controller, basic_logger) self.assertEqual(rc, 0, "Failed to delete all flows") # 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)) rv = self.controller.message_send(msg) self.assertTrue(rv == 0, "Error sending out message") (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): of_ports = testutils.clear_switch(self, exact_port_map.keys(), exact_logger) #zhaoxiuchu table_id = testutils.EX_L2_TABLE of_ports = exact_port_map.keys() egr_port = of_ports[1] pkt = testutils.simple_tcp_packet(dl_src='08:02:03:04:88:99', dl_dst='22:22:22:22:22:22') pkt_metadata = { 'metadata_val': 0xad22332e6f667588, 'metadata_msk': 0xFFFFFFFFFFFFFFFF } request = testutils.flow_msg_create(self, pkt, pkt_metadata, egr_port=egr_port, table_id=table_id) request.hard_timeout = 1 request.flags |= ofp.OFPFF_SEND_FLOW_REM testutils.flow_msg_install(self, request) #print(request.show()) (response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 3) self.assertTrue(response is not None, 'Did not receive flow removed message ') self.assertEqual(request.cookie, response.cookie, 'Cookies do not match') self.assertEqual( ofp.OFPRR_HARD_TIMEOUT, response.reason, 'Flow table entry removal reason is not idle_timeout')
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 2, "Not enough ports for test") pkt = testutils.simple_tcp_packet() for ingress_port in of_ports: rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") pa_logger.info("Ingress " + str(ingress_port) + " all non-ingress ports") actions = [] for egress_port in of_ports: act = action.action_output() if egress_port == ingress_port: continue act.port = egress_port actions.append(act) request = testutils.flow_msg_create(self, pkt, ing_port=ingress_port, action_list=actions, inst_app_flag=testutils.APPLY_ACTIONS_INSTRUCTION) pa_logger.info("Inserting flow") testutils.ofmsg_send(self, request) pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) yes_ports = set(of_ports).difference([ingress_port]) testutils.receive_pkt_check(self.dataplane, pkt, yes_ports, [ingress_port], self, pa_logger)
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") pkt = testutils.simple_tcp_packet() act_all = action.action_output() act_all.port = ofp.OFPP_ALL act_ing = action.action_output() act_ing.port = ofp.OFPP_IN_PORT actions = [ act_all, act_ing] for ingress_port in of_ports: rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") pa_logger.info("Ingress " + str(ingress_port) + " to all ports") flow_mod = testutils.flow_msg_create(self, pkt, ing_port=ingress_port, action_list=actions, wildcards=~ofp.OFPFW_IN_PORT) flow_mod.buffer_id = 0xffffffff pa_logger.info(flow_mod.show()) pa_logger.info("Inserting flow") rv = self.controller.message_send(flow_mod) self.assertTrue(rv != -1, "Error installing flow mod") testutils.do_barrier(self.controller) pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) testutils.receive_pkt_check(self.dataplane, pkt, of_ports, [], self, pa_logger)
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") pkt = testutils.simple_tcp_packet() act_all = action.action_output() act_all.port = ofp.OFPP_ALL act_ing = action.action_output() act_ing.port = ofp.OFPP_IN_PORT actions = [ act_all, act_ing] for ingress_port in of_ports: rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") pa_logger.info("Ingress " + str(ingress_port) + " to all ports") flow_mod = testutils.flow_msg_create(self, pkt, ing_port=ingress_port, action_list=actions, inst_app_flag=testutils.APPLY_ACTIONS_INSTRUCTION ) pa_logger.info(flow_mod.show()) pa_logger.info("Inserting flow") testutils.ofmsg_send(self, flow_mod) pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) testutils.receive_pkt_check(self.dataplane, pkt, of_ports, [], self, pa_logger)
def runTest(self): # Construct packet to send to dataplane # Send packet to dataplane, once to each port # Poll controller with expect message type packet in rc = testutils.delete_all_flows(self.controller, config_logger) self.assertEqual(rc, 0, "Failed to delete all flows") of_port = config_port_map.keys()[0] rv = testutils.port_config_set(self.controller, of_port, ofp.OFPPC_NO_PACKET_IN, ofp.OFPPC_NO_PACKET_IN, config_logger) self.assertTrue(rv != -1, "Error sending port mod") config_logger.info("NO PKT IN test, port " + str(of_port)) # make sure config is changed before sending the packet testutils.do_barrier(self.controller) 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) self.assertTrue( response is None, 'OFPPC_NO_PACKET_IN flag is ignored on port (got a packet when we asked not to) ' + str(of_port))
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): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 2, "Not enough ports for test") pkt = testutils.simple_tcp_packet() for ingress_port in of_ports: rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") pa_logger.info("Ingress " + str(ingress_port) + " all non-ingress ports") actions = [] for egress_port in of_ports: act = action.action_output() if egress_port == ingress_port: continue act.port = egress_port actions.append(act) request = testutils.flow_msg_create( self, pkt, ing_port=ingress_port, action_list=actions, inst_app_flag=testutils.APPLY_ACTIONS_INSTRUCTION) pa_logger.info("Inserting flow") testutils.ofmsg_send(self, request) pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) yes_ports = set(of_ports).difference([ingress_port]) testutils.receive_pkt_check(self.dataplane, pkt, yes_ports, [ingress_port], self, pa_logger)
def handleFlow(self, pkttype='TCP'): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") if (pkttype == 'ICMP'): pkt = testutils.simple_icmp_packet() table_id = testutils.EX_ICMP_TABLE else: pkt = testutils.simple_tcp_packet() table_id = testutils.WC_ACL_TABLE for idx in range(len(of_ports)): rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") testutils.set_table_config(self, table_id, ofp.OFPTC_TABLE_MISS_CONTINUE) ingress_port = of_ports[idx] egress_port = of_ports[(idx + 1) % len(of_ports)] pa_logger.info("Ingress " + str(ingress_port) + " to egress " + str(egress_port)) #controller send flow mod to switch request = testutils.flow_msg_create(self,pkt, ing_port=ingress_port, egr_port=egress_port, table_id=table_id) testutils.flow_msg_install(self, request) #user send pkt to switch pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) testutils.receive_pkt_verify(self, egress_port, pkt)
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") pkt = testutils.simple_tcp_packet() act_all = action.action_output() act_all.port = ofp.OFPP_ALL act_ing = action.action_output() act_ing.port = ofp.OFPP_IN_PORT actions = [act_all, act_ing] for ingress_port in of_ports: rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") pa_logger.info("Ingress " + str(ingress_port) + " to all ports") flow_mod = testutils.flow_msg_create( self, pkt, ing_port=ingress_port, action_list=actions, inst_app_flag=testutils.APPLY_ACTIONS_INSTRUCTION) pa_logger.info(flow_mod.show()) pa_logger.info("Inserting flow") testutils.ofmsg_send(self, flow_mod) pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) testutils.receive_pkt_check(self.dataplane, pkt, of_ports, [], self, pa_logger)
def runTest(self): # 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 handleFlow(self, pkttype='TCP'): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") if (pkttype == 'ICMP'): pkt = testutils.simple_icmp_packet() table_id = testutils.EX_ICMP_TABLE else: pkt = testutils.simple_tcp_packet() table_id = testutils.WC_ACL_TABLE for idx in range(len(of_ports)): rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") testutils.set_table_config(self, table_id, ofp.OFPTC_TABLE_MISS_CONTINUE) ingress_port = of_ports[idx] egress_port = of_ports[(idx + 1) % len(of_ports)] pa_logger.info("Ingress " + str(ingress_port) + " to egress " + str(egress_port)) #controller send flow mod to switch request = testutils.flow_msg_create(self, pkt, ing_port=ingress_port, egr_port=egress_port, table_id=table_id) testutils.flow_msg_install(self, request) #user send pkt to switch pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) testutils.receive_pkt_verify(self, egress_port, pkt)
def runTest(self): #"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): ing_port = flow_mods_port_map.keys()[0] out_port1 = ofp.OFPP_ALL pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) fm_orig = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port1) #flood inst = None inst = instruction.instruction_apply_actions() act = action.action_output() act.port = ofp.OFPP_IN_PORT #fwd to ingress rv = inst.actions.add(act) self.assertTrue(rv, "Could not add action" + act.show()) fm_orig.instructions.add(inst) #print(fm_orig.show()) testutils.ofmsg_send(self, fm_orig) (response, raw) = self.controller.poll(ofp.OFPT_ERROR, 2) self.assertTrue(response is None, 'Receive error message') #user sends packet self.dataplane.send(ing_port, str(pkt)) testutils.do_barrier(self.controller) #verify pkt for of_port in flow_mods_port_map.keys(): testutils.receive_pkt_verify(self, of_port, pkt)
def runTest(self): old_vid = 2 sup_acts = supported_actions_get(self) if not (sup_acts & 1 << ofp.OFPAT_POP_VLAN): testutils.skip_message_emit(self, "Strip VLAN tag test") return len_w_vid = 104 len = 100 pkt = testutils.simple_tcp_packet(pktlen=len_w_vid, dl_vlan_enable=True, dl_vlan=old_vid) exp_pkt = testutils.simple_tcp_packet(pktlen=len) vid_act = action.action_pop_vlan() testutils.flow_match_test(self, pa_port_map, pkt=pkt, exp_pkt=exp_pkt, apply_action_list=[vid_act])
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")