def runTest(self): ing_port = flow_mods_port_map.keys()[0] egr_port = flow_mods_port_map.keys()[1] table_id = testutils.EX_L3_TABLE flow_count = 10 testutils.delete_all_flows_one_table(self.controller, self.logger, table_id) match_fields_ls = [] ipv6_src_addr = 'fe80::2420:52ff:fe8f:5188' metadata_val = 0xaa22334455667788 for i in range(flow_count): match_fields_ls.append(match_list()) match_fields_ls[i].add(match.eth_type(testutils.IPV6_ETHERTYPE)) match_fields_ls[i].add( match.ipv6_src(ipaddr.IPv6Address(ipv6_src_addr))) ipv6_dst_addr = 'fe80::2420:52ff:fe8f:' + str(5190 + i) match_fields_ls[i].add( match.ipv6_dst(ipaddr.IPv6Address(ipv6_dst_addr))) match_fields_ls[i].add(match.metadata(metadata_val)) request = testutils.flow_msg_create( self, None, ing_port=ing_port, match_fields=match_fields_ls[i], egr_port=egr_port, table_id=table_id) testutils.flow_msg_install(self, request, False) match_fields = match_list() match_fields.add(match.eth_type(testutils.IPV6_ETHERTYPE)) match_fields.add(match.ipv6_src(ipaddr.IPv6Address(ipv6_src_addr))) response = testutils.flow_stats_get(self, table_id=table_id) self.assertTrue( len(response.stats) == flow_count, 'Did not add all flows successfully! Get table entry num is %d' % len(response.stats)) request = testutils.flow_msg_create(self, None, None, ing_port, match_fields, table_id=table_id) request.command = ofp.OFPFC_DELETE testutils.flow_msg_install(self, request, False) response = testutils.flow_stats_get(self, table_id=table_id) self.assertTrue( len(response.stats) == 0, 'Switch did not del the flow entry! Current table entry num is %d' % len(response.stats))
def runTest(self): 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): 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 = ipv6_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, ipv6_logger) self.assertEqual(rc, 0, "Failed to delete all flows") # Add entry match request = message.flow_mod() request.match.type = ofp.OFPMT_OXM port = match.in_port(of_ports[0]) eth_type = match.eth_type(IPV6_ETHERTYPE) ipv6_src = match.ipv6_src(ipaddr.IPv6Address('fe80::2420:52ff:fe8f:5189')) request.match_fields.tlvs.append(port) request.match_fields.tlvs.append(eth_type) request.match_fields.tlvs.append(ipv6_src) field_2b_set = match.ipv6_dst(ipaddr.IPv6Address('fe80::2420:52ff:fe8f:DDDD')) act_setfield = action.action_set_field() act_setfield.field = field_2b_set # TODO: insert action set field properly act_out = action.action_output() act_out.port = of_ports[3] inst = instruction.instruction_apply_actions() inst.actions.add(act_setfield) inst.actions.add(act_out) request.instructions.add(inst) request.buffer_id = 0xffffffff request.priority = 1000 ipv6_logger.debug("Adding flow ") rv = self.controller.message_send(request) self.assertTrue(rv != -1, "Failed to insert test flow") #Send packet pkt = testutils.simple_ipv6_packet(ip_src='fe80::2420:52ff:fe8f:5189',ip_dst='fe80::2420:52ff:fe8f:5190') ipv6_logger.info("Sending IPv6 packet to " + str(ing_port)) ipv6_logger.debug("Data: " + str(pkt).encode('hex')) self.dataplane.send(ing_port, str(pkt)) #Receive packet exp_pkt = testutils.simple_ipv6_packet(ip_dst='fe80::2420:52ff:fe8f:DDDD') testutils.receive_pkt_verify(self, egr_port, exp_pkt) #See flow match response = testutils.flow_stats_get(self) ipv6_logger.debug("Response" + response.show()) #Remove flows rc = testutils.delete_all_flows(self.controller, ipv6_logger) self.assertEqual(rc, 0, "Failed to delete all flows")
def runTest(self): ing_port = flow_mods_port_map.keys()[0] out_port1 = flow_mods_port_map.keys()[1] out_port2 = flow_mods_port_map.keys()[2] pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) fm_orig = testutils.flow_msg_create(self, pkt, ing_port=ofp.OFPP_ANY, egr_port=out_port1, table_id=2) fm_new = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port2, table_id=2) fm_new.command = ofp.OFPFC_MODIFY_STRICT testutils.ofmsg_send(self, fm_orig) testutils.ofmsg_send(self, fm_new) flow_stats = testutils.flow_stats_get(self) #print(flow_stats.show()) self.assertEqual(len(flow_stats.stats), 1, "Expected only one flow_mod") #fail to modify and instruction will remain the same stat = flow_stats.stats[0] self.assertEqual(stat.match, fm_orig.match) self.assertEqual(stat.instructions, fm_orig.instructions)
def runTest(self): of_ports = 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): basic_logger.info("Running StatsGet") basic_logger.info("Inserting trial flow") request = message.flow_mod() request.match.wildcards = OFPFW_ALL request.buffer_id = 0xffffffff testutils.ofmsg_send(self, request) basic_logger.info("Sending flow request") response = testutils.flow_stats_get(self) basic_logger.debug(response.show())
def runTest(self): basic_logger.info("Running StatsGet") basic_logger.info("Inserting trial flow") request = message.flow_mod() request.buffer_id = 0xffffffff rv = self.controller.message_send(request) self.assertTrue(rv != -1, "Failed to insert test flow") basic_logger.info("Sending flow request") response = testutils.flow_stats_get(self) basic_logger.debug(response.show())
def runTest(self): ing_port = flow_mods_port_map.keys()[0] egr_port = flow_mods_port_map.keys()[1] table_id = testutils.EX_L3_TABLE flow_count = 10 testutils.delete_all_flows_one_table(self.controller, self.logger, table_id) match_fields_ls = [] ipv6_src_addr = 'fe80::2420:52ff:fe8f:5188' metadata_val = 0xaa22334455667788 for i in range(flow_count): match_fields_ls.append(match_list()) match_fields_ls[i].add(match.eth_type(testutils.IPV6_ETHERTYPE)) match_fields_ls[i].add(match.ipv6_src(ipaddr.IPv6Address(ipv6_src_addr))) ipv6_dst_addr = 'fe80::2420:52ff:fe8f:' + str(5190+i) match_fields_ls[i].add(match.ipv6_dst(ipaddr.IPv6Address(ipv6_dst_addr))) match_fields_ls[i].add(match.metadata(metadata_val)) request = testutils.flow_msg_create(self, None, ing_port=ing_port, match_fields = match_fields_ls[i], egr_port = egr_port, table_id = table_id) testutils.flow_msg_install(self, request, False) match_fields = match_list() match_fields.add(match.eth_type(testutils.IPV6_ETHERTYPE)) match_fields.add(match.ipv6_src(ipaddr.IPv6Address(ipv6_src_addr))) response = testutils.flow_stats_get(self, table_id = table_id) self.assertTrue(len(response.stats) == flow_count, 'Did not add all flows successfully! Get table entry num is %d' %len(response.stats)) request = testutils.flow_msg_create(self, None, None, ing_port, match_fields, table_id = table_id) request.command = ofp.OFPFC_DELETE testutils.flow_msg_install(self, request, False) response = testutils.flow_stats_get(self, table_id = table_id) self.assertTrue(len(response.stats) == 0, 'Switch did not del the flow entry! Current table entry num is %d' %len(response.stats))
def runTest(self): ing_port = flow_mods_port_map.keys()[0] out_port1 = flow_mods_port_map.keys()[1] out_port2 = flow_mods_port_map.keys()[2] pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) fm_orig = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port1) fm_new = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port2) fm_new.command = ofp.OFPFC_MODIFY_STRICT testutils.ofmsg_send(self, fm_orig) testutils.ofmsg_send(self, fm_new) flow_stats = testutils.flow_stats_get(self) self.assertEqual(len(flow_stats.stats),1, "Expected only one flow_mod") stat = flow_stats.stats[0] #self.assertEqual(stat.match_fields, fm_new.match_fields) self.assertEqual(stat.instructions, fm_new.instructions, "instructions not equal !")
def runTest(self): ing_port = flow_mods_port_map.keys()[0] out_port1 = flow_mods_port_map.keys()[1] out_port2 = flow_mods_port_map.keys()[2] pkt = testutils.simple_tcp_packet() testutils.delete_all_flows(self.controller, self.logger) fm_orig = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port1) fm_new = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=out_port2) fm_new.command = ofp.OFPFC_MODIFY_STRICT testutils.ofmsg_send(self, fm_orig) testutils.ofmsg_send(self, fm_new) flow_stats = testutils.flow_stats_get(self) self.assertEqual(len(flow_stats.stats), 1, "Expected only one flow_mod") stat = flow_stats.stats[0] #self.assertEqual(stat.match_fields, fm_new.match_fields) self.assertEqual(stat.instructions, fm_new.instructions, "instructions not equal !")
def runTest(self): 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): #"verifying with set_async_request, switch will not send flow removed" #step 1-1:controller sends set_async_request msg async_logger.info("Sending set_async_request") of_ports = async_port_map.keys() of_ports.sort() ing_port = of_ports[0] egr_port = of_ports[1] mask = 1 << ofp.OFPRR_DELETE request_set = create_set_async(flow_rm_mstr=mask) testutils.ofmsg_send(self, request_set) #result 1-1: contrller sends msg successfully #"step 2-1:clear all flow entry" testutils.delete_all_flows(self.controller, async_logger) response, _ = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 2) while response != None: response, _ = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 1) pkt = testutils.simple_tcp_packet(vlan_tags=[{ 'type': 0x8100, 'vid': 5, 'pcp': 1 }]) request = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=egr_port, table_id=testutils.EX_VLAN_TABLE, check_expire=True) request.cookie = random.randint(0, 0xffffffffffffffff) testutils.flow_msg_install(self, request) "delete it" request.command = ofp.OFPFC_DELETE testutils.flow_msg_install(self, request) #"receive flow removed msg" (response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 2) self.assertTrue(response is not None, 'Not receive flow removed message ') self.assertTrue(response.reason == ofp.OFPRR_DELETE, 'Not OFPRR_DELETE reason') self.assertTrue(response.cookie == request.cookie, 'Cookie is not equal') #self.assertTrue(response.match_fields == request.match_fields, # 'Match_fields is not equal') #'read it back , returns blank;' response = testutils.flow_stats_get(self, request.match_fields, request.table_id) self.assertEqual(len(response.stats), 0, "len of stats is:" + str(len(response.stats))) #print(response.show()) #"verifying with set_async_request, switch will not send flow removed" "step 1-2:controller sends set_async_request msg" async_logger.info("Sending set_async_request") mask = 0xffffffff ^ (1 << ofp.OFPRR_DELETE) request_set = create_set_async(flow_rm_mstr=mask) testutils.ofmsg_send(self, request_set) "result 1-2: contrller sends msg successfully" "step 2-2:clear all flow entry" testutils.delete_all_flows(self.controller, async_logger) response, _ = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 2) while response != None: response, _ = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 1) #table_id = 3 "add a flow entry" request.command = ofp.OFPFC_ADD testutils.flow_msg_install(self, request) "delete it" request.command = ofp.OFPFC_DELETE testutils.flow_msg_install(self, request) "receive no flow removed msg" (response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 2) self.assertTrue(response is None, 'Receive flow removed message ') 'read it back , returns blank;' response = testutils.flow_stats_get(self, request.match_fields, request.table_id) self.assertEqual(len(response.stats), 0, "len of stats is:" + str(len(response.stats))) #print(response.show()) msg = create_set_async() set_async_verify(self, msg)
def runTest(self): of_ports = async_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") #"verifying without set_async_request, switch will send flow removed" #step 1-1:controller sends set_async_request msg async_logger.info("Sending set_async_request") mask = 1 << ofp.OFPRR_HARD_TIMEOUT request_set = create_set_async(flow_rm_mstr = mask) testutils.ofmsg_send(self, request_set) #result 1-1: contrller sends msg successfully #step 2-1:clear all flow entry testutils.delete_all_flows(self.controller, async_logger) response,_ = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 2) while response != None: response,_ = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 1) #step 3-1:insert a flow entry: idle_timeout=1 pkt = testutils.simple_tcp_packet() ing_port = of_ports[0] egr_port = of_ports[1] async_logger.info("Ingress " + str(ing_port) + " to egress " + str(egr_port)) request = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=egr_port, table_id = testutils.WC_ALL_TABLE, check_expire=True) request.cookie = random.randint(0,0xffffffffffffffff) testutils.flow_msg_install(self, request) #step 4-1: wait for 2sec, make sure no ofp_flow_removed msg (response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 5) self.assertTrue(response is not None, 'Not receive flow removed message') self.assertTrue(response.reason == ofp.OFPRR_HARD_TIMEOUT, 'Not OFPRR_HARD_TIMEOUT reason') self.assertTrue(response.cookie == request.cookie, 'Cookie is not equal') #self.assertTrue(response.match_fields == request.match_fields, # 'Match_fields is not equal') #step 5-1: verify there is no flow entry async_logger.info("Sending flow request") response = testutils.flow_stats_get(self, request.match_fields, request.table_id) async_logger.debug(response.show()) self.assertEqual(len(response.stats),0, "len of stats is:"+str(len(response.stats))) #"verifying with set_async_request, switch will not send flow removed" #step 1-2:controller sends set_async_request msg async_logger.info("Sending set_async_request") mask = 0xffffffff ^ (1 << ofp.OFPRR_HARD_TIMEOUT) request_set = create_set_async(flow_rm_mstr = mask) testutils.ofmsg_send(self, request_set) #result 1-2: contrller sends msg successfully #step 2-2:clear all flow entry testutils.delete_all_flows(self.controller, async_logger) response,_ = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 2) while response != None: response,_ = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 1) #step 3-2:insert a flow entry: idle_timeout=1 async_logger.info("Ingress " + str(ing_port) + " to egress " + str(egr_port)) testutils.flow_msg_install(self, request) #step 4-2: wait for 2sec, make sure no ofp_flow_removed msg (response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 5) self.assertTrue(response is None, 'Receive flow removed message ') #step 5-2: verify there is no flow entry async_logger.info("Sending flow request") response = testutils.flow_stats_get(self) async_logger.debug(response.show()) self.assertEqual(len(response.stats),0, "len of stats is:"+str(len(response.stats))) msg = create_set_async() set_async_verify(self, msg)
def runTest(self): of_ports = ipv6_port_map.keys() of_ports.sort() ing_port = of_ports[0] egr_port = of_ports[2] table_id1 = testutils.EX_L3_TABLE table_id2 = testutils.WC_ALL_TABLE # Remove all entries Add entry match all rc = testutils.delete_all_flows(self.controller, ipv6_logger) self.assertEqual(rc, 0, "Failed to delete all flows") rv = testutils.set_table_config(self, table_id = table_id1) self.assertEqual(rv, 0, "Failed to set table config") # Add entry match pkt = testutils.simple_ipv6_packet(ip_dst='fe80::1:0:1234') pkt_metadata = {'metadata_val':0xabcdef0123456789, 'metadata_msk':0xffffffffffffffff} inst_ls1 = [] inst1_write = instruction.instruction_write_metadata() inst1_write.metadata = pkt_metadata['metadata_val'] inst1_write.metadata_mask = pkt_metadata['metadata_msk'] inst1_goto = instruction.instruction_goto_table() inst1_goto.table_id = table_id2 inst_ls1.append(inst1_write) inst_ls1.append(inst1_goto) request1 = testutils.flow_msg_create(self, pkt, ing_port = ing_port, instruction_list = inst_ls1, table_id = table_id1) testutils.flow_msg_install(self, request1) act_ls2 = [] act2_setfld = action.action_set_field() act2_setfld.field = match.ipv6_dst(ipaddr.IPv6Address('fe80::1:6554:3e7f:1')) act2_out = action.action_output() act2_out.port = egr_port act_ls2.append(act2_setfld) act_ls2.append(act2_out) pkt_metadata = {'metadata_val':0xabcdef0100000000, 'metadata_msk':0xffffffff00000000} request2 = testutils.flow_msg_create(self, pkt, pkt_metadata, ing_port, action_list = act_ls2, table_id = table_id2) testutils.flow_msg_install(self, request2) #Send packet ipv6_logger.info("Sending IPv6 packet to " + str(ing_port)) ipv6_logger.debug("Data: " + str(pkt).encode('hex')) self.dataplane.send(ing_port, str(pkt)) #Receive packet exp_pkt = testutils.simple_ipv6_packet(ip_dst='fe80::1:6554:3e7f:1') testutils.receive_pkt_verify(self, egr_port, exp_pkt) #See flow match response = testutils.flow_stats_get(self) ipv6_logger.debug("Response" + response.show()) #Remove flows rc = testutils.delete_all_flows(self.controller, ipv6_logger) self.assertEqual(rc, 0, "Failed to delete all flows")
def runTest(self): #"verifying with set_async_request, switch will not send flow removed" #step 1-1:controller sends set_async_request msg async_logger.info("Sending set_async_request") of_ports = async_port_map.keys() of_ports.sort() ing_port = of_ports[0] egr_port = of_ports[1] mask = 1 << ofp.OFPRR_DELETE request_set = create_set_async(flow_rm_mstr = mask) testutils.ofmsg_send(self, request_set) #result 1-1: contrller sends msg successfully #"step 2-1:clear all flow entry" testutils.delete_all_flows(self.controller, async_logger) response,_ = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 2) while response != None: response,_ = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 1) pkt = testutils.simple_tcp_packet( vlan_tags=[{'type': 0x8100, 'vid': 5, 'pcp': 1}]) request = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=egr_port, table_id = testutils.EX_VLAN_TABLE, check_expire=True) request.cookie = random.randint(0,0xffffffffffffffff) testutils.flow_msg_install(self, request) "delete it" request.command = ofp.OFPFC_DELETE testutils.flow_msg_install(self, request) #"receive flow removed msg" (response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 2) self.assertTrue(response is not None, 'Not receive flow removed message ') self.assertTrue(response.reason == ofp.OFPRR_DELETE, 'Not OFPRR_DELETE reason') self.assertTrue(response.cookie == request.cookie, 'Cookie is not equal') #self.assertTrue(response.match_fields == request.match_fields, # 'Match_fields is not equal') #'read it back , returns blank;' response = testutils.flow_stats_get(self, request.match_fields, request.table_id) self.assertEqual(len(response.stats),0, "len of stats is:"+str(len(response.stats))) #print(response.show()) #"verifying with set_async_request, switch will not send flow removed" "step 1-2:controller sends set_async_request msg" async_logger.info("Sending set_async_request") mask = 0xffffffff ^ (1 << ofp.OFPRR_DELETE) request_set = create_set_async(flow_rm_mstr = mask) testutils.ofmsg_send(self, request_set) "result 1-2: contrller sends msg successfully" "step 2-2:clear all flow entry" testutils.delete_all_flows(self.controller, async_logger) response,_ = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 2) while response != None: response,_ = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 1) #table_id = 3 "add a flow entry" request.command = ofp.OFPFC_ADD testutils.flow_msg_install(self, request) "delete it" request.command = ofp.OFPFC_DELETE testutils.flow_msg_install(self, request) "receive no flow removed msg" (response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 2) self.assertTrue(response is None, 'Receive flow removed message ') 'read it back , returns blank;' response = testutils.flow_stats_get(self, request.match_fields, request.table_id) self.assertEqual(len(response.stats),0, "len of stats is:"+str(len(response.stats))) #print(response.show()) msg = create_set_async() set_async_verify(self, msg)
def runTest(self): of_ports = ipv6_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, ipv6_logger) self.assertEqual(rc, 0, "Failed to delete all flows") # Add entry match request = message.flow_mod() request.match.type = ofp.OFPMT_OXM port = match.in_port(of_ports[0]) eth_type = match.eth_type(IPV6_ETHERTYPE) ipv6_src = match.ipv6_src( ipaddr.IPv6Address('fe80::2420:52ff:fe8f:5189')) request.match_fields.tlvs.append(port) request.match_fields.tlvs.append(eth_type) request.match_fields.tlvs.append(ipv6_src) field_2b_set = match.ipv6_dst( ipaddr.IPv6Address('fe80::2420:52ff:fe8f:DDDD')) act_setfield = action.action_set_field() act_setfield.field = field_2b_set # TODO: insert action set field properly act_out = action.action_output() act_out.port = of_ports[3] inst = instruction.instruction_apply_actions() inst.actions.add(act_setfield) inst.actions.add(act_out) request.instructions.add(inst) request.buffer_id = 0xffffffff request.priority = 1000 ipv6_logger.debug("Adding flow ") rv = self.controller.message_send(request) self.assertTrue(rv != -1, "Failed to insert test flow") #Send packet pkt = testutils.simple_ipv6_packet(ip_src='fe80::2420:52ff:fe8f:5189', ip_dst='fe80::2420:52ff:fe8f:5190') ipv6_logger.info("Sending IPv6 packet to " + str(ing_port)) ipv6_logger.debug("Data: " + str(pkt).encode('hex')) self.dataplane.send(ing_port, str(pkt)) #Receive packet exp_pkt = testutils.simple_ipv6_packet( ip_dst='fe80::2420:52ff:fe8f:DDDD') testutils.receive_pkt_verify(self, egr_port, exp_pkt) #See flow match response = testutils.flow_stats_get(self) ipv6_logger.debug("Response" + response.show()) #Remove flows rc = testutils.delete_all_flows(self.controller, ipv6_logger) self.assertEqual(rc, 0, "Failed to delete all flows")
def runTest(self): of_ports = async_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") #"verifying without set_async_request, switch will send flow removed" #step 1-1:controller sends set_async_request msg async_logger.info("Sending set_async_request") mask = 1 << ofp.OFPRR_HARD_TIMEOUT request_set = create_set_async(flow_rm_mstr=mask) testutils.ofmsg_send(self, request_set) #result 1-1: contrller sends msg successfully #step 2-1:clear all flow entry testutils.delete_all_flows(self.controller, async_logger) response, _ = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 2) while response != None: response, _ = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 1) #step 3-1:insert a flow entry: idle_timeout=1 pkt = testutils.simple_tcp_packet() ing_port = of_ports[0] egr_port = of_ports[1] async_logger.info("Ingress " + str(ing_port) + " to egress " + str(egr_port)) request = testutils.flow_msg_create(self, pkt, ing_port=ing_port, egr_port=egr_port, table_id=testutils.WC_ALL_TABLE, check_expire=True) request.cookie = random.randint(0, 0xffffffffffffffff) testutils.flow_msg_install(self, request) #step 4-1: wait for 2sec, make sure no ofp_flow_removed msg (response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 5) self.assertTrue(response is not None, 'Not receive flow removed message') self.assertTrue(response.reason == ofp.OFPRR_HARD_TIMEOUT, 'Not OFPRR_HARD_TIMEOUT reason') self.assertTrue(response.cookie == request.cookie, 'Cookie is not equal') #self.assertTrue(response.match_fields == request.match_fields, # 'Match_fields is not equal') #step 5-1: verify there is no flow entry async_logger.info("Sending flow request") response = testutils.flow_stats_get(self, request.match_fields, request.table_id) async_logger.debug(response.show()) self.assertEqual(len(response.stats), 0, "len of stats is:" + str(len(response.stats))) #"verifying with set_async_request, switch will not send flow removed" #step 1-2:controller sends set_async_request msg async_logger.info("Sending set_async_request") mask = 0xffffffff ^ (1 << ofp.OFPRR_HARD_TIMEOUT) request_set = create_set_async(flow_rm_mstr=mask) testutils.ofmsg_send(self, request_set) #result 1-2: contrller sends msg successfully #step 2-2:clear all flow entry testutils.delete_all_flows(self.controller, async_logger) response, _ = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 2) while response != None: response, _ = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 1) #step 3-2:insert a flow entry: idle_timeout=1 async_logger.info("Ingress " + str(ing_port) + " to egress " + str(egr_port)) testutils.flow_msg_install(self, request) #step 4-2: wait for 2sec, make sure no ofp_flow_removed msg (response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 5) self.assertTrue(response is None, 'Receive flow removed message ') #step 5-2: verify there is no flow entry async_logger.info("Sending flow request") response = testutils.flow_stats_get(self) async_logger.debug(response.show()) self.assertEqual(len(response.stats), 0, "len of stats is:" + str(len(response.stats))) msg = create_set_async() set_async_verify(self, msg)
def runTest(self): of_ports = ipv6_port_map.keys() of_ports.sort() ing_port = of_ports[0] egr_port = of_ports[2] table_id1 = testutils.EX_L3_TABLE table_id2 = testutils.WC_ALL_TABLE # Remove all entries Add entry match all rc = testutils.delete_all_flows(self.controller, ipv6_logger) self.assertEqual(rc, 0, "Failed to delete all flows") rv = testutils.set_table_config(self, table_id=table_id1) self.assertEqual(rv, 0, "Failed to set table config") # Add entry match pkt = testutils.simple_ipv6_packet(ip_dst='fe80::1:0:1234') pkt_metadata = { 'metadata_val': 0xabcdef0123456789, 'metadata_msk': 0xffffffffffffffff } inst_ls1 = [] inst1_write = instruction.instruction_write_metadata() inst1_write.metadata = pkt_metadata['metadata_val'] inst1_write.metadata_mask = pkt_metadata['metadata_msk'] inst1_goto = instruction.instruction_goto_table() inst1_goto.table_id = table_id2 inst_ls1.append(inst1_write) inst_ls1.append(inst1_goto) request1 = testutils.flow_msg_create(self, pkt, ing_port=ing_port, instruction_list=inst_ls1, table_id=table_id1) testutils.flow_msg_install(self, request1) act_ls2 = [] act2_setfld = action.action_set_field() act2_setfld.field = match.ipv6_dst( ipaddr.IPv6Address('fe80::1:6554:3e7f:1')) act2_out = action.action_output() act2_out.port = egr_port act_ls2.append(act2_setfld) act_ls2.append(act2_out) pkt_metadata = { 'metadata_val': 0xabcdef0100000000, 'metadata_msk': 0xffffffff00000000 } request2 = testutils.flow_msg_create(self, pkt, pkt_metadata, ing_port, action_list=act_ls2, table_id=table_id2) testutils.flow_msg_install(self, request2) #Send packet ipv6_logger.info("Sending IPv6 packet to " + str(ing_port)) ipv6_logger.debug("Data: " + str(pkt).encode('hex')) self.dataplane.send(ing_port, str(pkt)) #Receive packet exp_pkt = testutils.simple_ipv6_packet(ip_dst='fe80::1:6554:3e7f:1') testutils.receive_pkt_verify(self, egr_port, exp_pkt) #See flow match response = testutils.flow_stats_get(self) ipv6_logger.debug("Response" + response.show()) #Remove flows rc = testutils.delete_all_flows(self.controller, ipv6_logger) self.assertEqual(rc, 0, "Failed to delete all flows")