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): """ 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): 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 setup_table_config(parent, table_id, table_config): request = message.table_mod() request.table_id = table_id request.config = table_config rv = parent.controller.message_send(request) parent.assertTrue(rv != -1, "Error configuring table") testutils.do_barrier(parent.controller)
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): basic_logger.info("Running TableStats") testutils.delete_all_flows(self.controller, self.logger) basic_logger.info("Sending table stats request") request = message.table_stats_request() response, _ = self.controller.transact(request, timeout=2) # delete everything, so there should be no entries self.assertEqual(self.get_first_table_active_entries(response), 0) # add two entries to first table m1 = testutils.match_all_generate() m1.dl_type = 0x800 m1.wildcards ^= ofp.OFPFW_DL_TYPE fm1 = testutils.flow_msg_create(self, None, match=m1, egr_port=2) rv = self.controller.message_send(fm1) self.assertEqual(rv, 0) m2 = testutils.match_all_generate() m2.dl_type = 0x806 m2.wildcards ^= ofp.OFPFW_DL_TYPE fm2 = testutils.flow_msg_create(self, None, match=m2, egr_port=2) rv = self.controller.message_send(fm2) self.assertEqual(rv, 0) testutils.do_barrier(self.controller) response, _ = self.controller.transact(request, timeout=2) self.assertEqual(self.get_first_table_active_entries(response), 2)
def runTest(self): # 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): 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): 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 send_ctrl_exp_error(self, msg, log='', type=0, code=0): group_logger.info('Sending message ' + log) group_logger.debug(msg.show()) rv = self.controller.message_send(msg) self.assertTrue(rv != -1, 'Error sending!') group_logger.info('Waiting for error messages...') (response, raw) = self.controller.poll(ofp.OFPT_ERROR, 1) self.assertTrue(response is not None, 'Did not receive an error message') self.assertEqual(response.header.type, ofp.OFPT_ERROR, 'Did not receive an error message') if type != 0: self.assertEqual( response.type, type, 'Did not receive a ' + str(type) + ' type error message') if code != 0: self.assertEqual( response.code, code, 'Did not receive a ' + str(code) + ' code error message') testutils.do_barrier(self.controller)
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 2, "Not enough ports for test") pkt = testutils.simple_tcp_packet() for ingress_port in of_ports: rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") pa_logger.info("Ingress " + str(ingress_port) + " to all ports") actions = [] for egress_port in of_ports: act = action.action_output() if egress_port == ingress_port: act.port = ofp.OFPP_IN_PORT else: act.port = egress_port actions.append(act) request = testutils.flow_msg_create(self, pkt, ingress_port, action_list=actions) request.buffer_id = 0xffffffff # pa_logger.info(request.show()) pa_logger.info("Inserting flow") rv = self.controller.message_send(request) self.assertTrue(rv != -1, "Error installing flow mod") testutils.do_barrier(self.controller) pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) testutils.receive_pkt_check(self.dataplane, pkt, of_ports, [], self, pa_logger)
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") pkt = testutils.simple_tcp_packet() act_all = action.action_output() act_all.port = ofp.OFPP_ALL act_ing = action.action_output() act_ing.port = ofp.OFPP_IN_PORT actions = [ act_all, act_ing] for ingress_port in of_ports: rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") pa_logger.info("Ingress " + str(ingress_port) + " to all ports") flow_mod = testutils.flow_msg_create(self, pkt, ing_port=ingress_port, action_list=actions, wildcards=~ofp.OFPFW_IN_PORT) flow_mod.buffer_id = 0xffffffff pa_logger.info(flow_mod.show()) pa_logger.info("Inserting flow") rv = self.controller.message_send(flow_mod) self.assertTrue(rv != -1, "Error installing flow mod") testutils.do_barrier(self.controller) pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) testutils.receive_pkt_check(self.dataplane, pkt, of_ports, [], self, pa_logger)
def runTest(self): ing_port = flow_mods_port_map.keys()[0] out_port1 = 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): 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): 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): 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 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): #testutils.clear_switch(self,pa_port_map,pa_logger) testutils.delete_all_flows(self.controller, pa_logger) of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") pkt = testutils.simple_tcp_packet() #match_ls = packet_to_exact_flow_match(pkt = pkt, table_id = 0, in_port = of_ports[0]) match_ls = parse.packet_to_flow_match(pkt) request = message.flow_mod() request.match_fields = match_ls request.flags = 0x18 #set flags OFPFF_NO_PKT_COUNTS and OFPFF_NO_BYT_COUNTS action_list = [] act = action.action_output() act.port = of_ports[1] action_list.append(act) inst = None instruction_list = [] if len(instruction_list) == 0: inst = instruction.instruction_apply_actions() instruction_list.append(inst) for act in action_list: rv = inst.actions.add(act) self.assertTrue(rv, "Could not add action" + act.show()) for i in instruction_list: rv = request.instructions.add(i) self.assertTrue(rv, "Could not add instruction " + i.show()) #testutils.message_send(self, request) rv0 = self.controller.message_send(request) self.assertTrue(rv0 != -1, "Error sending flow mod") testutils.do_barrier(self.controller) #self.send_data(pkt, of_ports[0]) self.dataplane.send(of_ports[0], str(pkt)) aggregate_stats_req = message.aggregate_stats_request() aggregate_stats_req.match_fields = match_ls rv = self.controller.message_send(aggregate_stats_req) self.assertTrue(rv != -1, "Error sending flow stat req") #testutils.message_send(self, aggregate_stats_req) (response, _) = self.controller.poll(ofp.OFPT_MULTIPART_REPLY, 2) #print(response.show()) self.assertTrue(response is not None, "No aggregate_stats reply") self.assertEqual(len(response.stats), 1, "Did not receive aggregate stats reply") self.assertEqual(response.stats[0].packet_count, 0) #1) self.assertEqual(response.stats[0].byte_count, 0) #len(packet_in))
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): #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,pa_port_map,pa_logger) testutils.delete_all_flows(self.controller, pa_logger) of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") pkt = testutils.simple_tcp_packet() #match_ls = packet_to_exact_flow_match(pkt = pkt, table_id = 0, in_port = of_ports[0]) match_ls = parse.packet_to_flow_match(pkt) request = message.flow_mod() request.match_fields = match_ls request.flags = 0x18#set flags OFPFF_NO_PKT_COUNTS and OFPFF_NO_BYT_COUNTS action_list = [] act = action.action_output() act.port = of_ports[1] action_list.append(act) inst = None instruction_list = [] if len(instruction_list) == 0: inst = instruction.instruction_apply_actions() instruction_list.append(inst) for act in action_list: rv = inst.actions.add(act) self.assertTrue(rv, "Could not add action" + act.show()) for i in instruction_list: rv = request.instructions.add(i) self.assertTrue(rv, "Could not add instruction " + i.show()) #testutils.message_send(self, request) rv0 = self.controller.message_send(request) self.assertTrue( rv0 != -1, "Error sending flow mod") testutils.do_barrier(self.controller) #self.send_data(pkt, of_ports[0]) self.dataplane.send(of_ports[0],str(pkt)) aggregate_stats_req = message.aggregate_stats_request() aggregate_stats_req.match_fields = match_ls rv = self.controller.message_send(aggregate_stats_req) self.assertTrue( rv != -1, "Error sending flow stat req") #testutils.message_send(self, aggregate_stats_req) (response, _) = self.controller.poll(ofp.OFPT_MULTIPART_REPLY, 2) #print(response.show()) self.assertTrue(response is not None, "No aggregate_stats reply") self.assertEqual(len(response.stats), 1, "Did not receive aggregate stats reply") self.assertEqual(response.stats[0].packet_count,0)#1) self.assertEqual(response.stats[0].byte_count,0)#len(packet_in))
def send_ctrl_exp_noerror(self, msg, log = ''): group_logger.info('Sending message ' + log) # group_logger.debug(msg.show()) rv = self.controller.message_send(msg) self.assertTrue(rv != -1, 'Error sending!') group_logger.info('Waiting for error messages...') (response, raw) = self.controller.poll(ofp.OFPT_ERROR, 1) self.assertTrue(response is None, 'Unexpected error message received') testutils.do_barrier(self.controller);
def runTest(self): vlan_tags = [{'type': 0x8100, 'vid': 3, 'pcp': 1}] mpls_tags = [{'type': 0x8847, 'label': 22, 'tc': 2, 'ttl': 48}] ing_port = exact_port_map.keys()[0] egr_port = exact_port_map.keys()[1] #"clear swtich;" testutils.delete_all_flows(self.controller, self.logger) "make test packet;" pkt = testutils.simple_tcp_packet(vlan_tags=vlan_tags, mpls_tags=mpls_tags) match_ls = testutils.packet_to_exact_flow_match( pkt=pkt, table_id=testutils.EX_ACL_TABLE, ing_port=ing_port) exact_table_goto_table(self, testutils.EX_ACL_TABLE, testutils.EX_L2_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match( pkt=pkt, table_id=testutils.EX_L2_TABLE, ing_port=ing_port) exact_table_goto_table(self, testutils.EX_L2_TABLE, testutils.EX_VLAN_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match( pkt=pkt, table_id=testutils.EX_VLAN_TABLE, ing_port=ing_port) exact_table_goto_table(self, testutils.EX_VLAN_TABLE, testutils.EX_MPLS_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match( pkt=pkt, table_id=testutils.EX_MPLS_TABLE, ing_port=ing_port) exact_table_goto_table(self, testutils.EX_MPLS_TABLE, testutils.EX_L3_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match( pkt=pkt, table_id=testutils.EX_L3_TABLE, ing_port=ing_port) exact_table_output(self, testutils.EX_L3_TABLE, match_ls, egr_port=egr_port) testutils.do_barrier(self.controller) "send a packet from ing_port " self.dataplane.send(ing_port, str(pkt)) "poll from the egr_port port" (port_rec, pkt_rec, _) = self.dataplane.poll(port_number=egr_port, timeout=1) self.assertTrue(pkt_rec is not None, "rec none packets") #print("++++++++++++++++++++++rcv_pkt++++++++++++++++++++++") #if pkt_rec is None: # print(str(pkt_rec)) #else: # print(str(pkt_rec).encode('hex')) self.assertEqual(str(pkt), str(pkt_rec), 'retruned pkt not equal to the original pkt')
def send_ctrl_exp_noerror(self, msg, log = ''): group_logger.info('Sending message ' + log) group_logger.debug(msg.show()) rv = self.controller.message_send(msg) self.assertTrue(rv != -1, 'Error sending!') group_logger.info('Waiting for error messages...') (response, raw) = self.controller.poll(ofp.OFPT_ERROR, 1) self.assertTrue(response is None, 'Unexpected error message received') testutils.do_barrier(self.controller);
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() else: pkt = testutils.simple_tcp_packet() match = parse.packet_to_flow_match(pkt) self.assertTrue(match is not None, "Could not generate flow match from pkt") match.wildcards &= ~ofp.OFPFW_IN_PORT act = action.action_output() for idx in range(len(of_ports)): rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") ingress_port = of_ports[idx] egress_port = of_ports[(idx + 1) % len(of_ports)] pa_logger.info("Ingress " + str(ingress_port) + " to egress " + str(egress_port)) match.in_port = ingress_port request = message.flow_mod() request.command = ofp.OFPFC_ADD request.match = match request.buffer_id = 0xffffffff inst = instruction.instruction_apply_actions() act.port = egress_port self.assertTrue(inst.actions.add(act), "Could not add action") self.assertTrue(request.instructions.add(inst), "Could not add instruction") 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)) (rcv_port, rcv_pkt, _) = self.dataplane.poll(timeout=1) self.assertTrue(rcv_pkt is not None, "Did not receive packet") pa_logger.debug("Packet len " + str(len(rcv_pkt)) + " in on " + str(rcv_port)) self.assertEqual(rcv_port, egress_port, "Unexpected receive port") self.assertEqual(str(pkt), str(rcv_pkt), 'Response packet does not match send packet')
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): # 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 set_apply_output(self, table_id, outport, add_inst=None): act = action.action_output() act.port = outport request = message.flow_mod() request.match = make_match() request.buffer_id = 0xffffffff request.table_id = table_id inst = instruction.instruction_apply_actions() self.assertTrue(inst.actions.add(act), "Can't add action") self.assertTrue(request.instructions.add(inst), "Can't add inst") if add_inst is not None: self.assertTrue(request.instructions.add(add_inst), "Can't add inst") pa_logger.info("Inserting flow") rv = self.controller.message_send(request) self.assertTrue(rv != -1, "Error installing flow mod") testutils.do_barrier(self.controller)
def write_goto(parent, set_id, next_id, ip_src=MT_TEST_IP, add_inst=None): """ Make flow_mod of Goto table instruction """ request = message.flow_mod() request.match = make_match(ip_src=ip_src) request.buffer_id = 0xffffffff request.table_id = set_id if add_inst is not None: parent.assertTrue(request.instructions.add(add_inst), "Can't add inst") inst = instruction.instruction_goto_table() inst.table_id = next_id parent.assertTrue(request.instructions.add(inst), "Can't add inst") pa_logger.info("Inserting flow") rv = parent.controller.message_send(request) parent.assertTrue(rv != -1, "Error installing flow mod") testutils.do_barrier(parent.controller)
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 2, "Not enough ports for test") pkt = testutils.simple_tcp_packet() match = parse.packet_to_flow_match(pkt) match.wildcards &= ~ofp.OFPFW_IN_PORT self.assertTrue(match is not None, "Could not generate flow match from pkt") act1 = action.action_output() act2 = action.action_output() for idx in range(len(of_ports)): rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") ingress_port = of_ports[idx] egress_port1 = of_ports[(idx + 1) % len(of_ports)] egress_port2 = of_ports[(idx + 2) % len(of_ports)] pa_logger.info("Ingress " + str(ingress_port) + " to egress " + str(egress_port1) + " and " + str(egress_port2)) match.in_port = ingress_port act1.port = egress_port1 act2.port = egress_port2 request = testutils.flow_msg_create(self, pkt, ingress_port, action_list=[act1, act2]) request.buffer_id = 0xffffffff pa_logger.info("Inserting flow") rv = self.controller.message_send(request) self.assertTrue(rv != -1, "Error installing flow mod") testutils.do_barrier(self.controller) pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) yes_ports = set([egress_port1, egress_port2]) no_ports = set(of_ports).difference(yes_ports) testutils.receive_pkt_check(self.dataplane, pkt, yes_ports, no_ports, self, pa_logger)
def runTest(self): # 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 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 write_output(parent, set_id, outport, ip_src=MT_TEST_IP, match=None): """ Make flow_mod of Write_action instruction of Output """ act = action.action_output() act.port = outport request = message.flow_mod() if match is None: request.match = make_match(ip_src=ip_src) else: request.match = match request.buffer_id = 0xffffffff request.table_id = set_id inst = instruction.instruction_write_actions() parent.assertTrue(inst.actions.add(act), "Can't add action") parent.assertTrue(request.instructions.add(inst), "Can't add inst") pa_logger.info("Inserting flow") rv = parent.controller.message_send(request) parent.assertTrue(rv != -1, "Error installing flow mod") testutils.do_barrier(parent.controller)
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): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") pkt = testutils.simple_tcp_packet() # match = parse.packet_to_flow_match(pkt) # match.wildcards &= ~ofp.OFPFW_IN_PORT # self.assertTrue(match is not None, # "Could not generate flow match from pkt") # act = action.action_output() for ingress_port in of_ports: rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") pa_logger.info("Ingress " + str(ingress_port) + " to all ports") # match.in_port = ingress_port # # request = message.flow_mod() # request.match = match # request.buffer_id = 0xffffffff # act.port = ofp.OFPP_ALL # self.assertTrue(request.actions.add(act), # "Could not add ALL port action") request = testutils.flow_msg_create(self, pkt, ing_port=ingress_port, egr_port=ofp.OFPP_ALL) # already done in flow_msg_create #pa_logger.info(request.show()) pa_logger.info("Inserting flow") rv = self.controller.message_send(request) self.assertTrue(rv != -1, "Error installing flow mod") testutils.do_barrier(self.controller) pa_logger.info("Sending packet to dp port " + str(ingress_port)) self.dataplane.send(ingress_port, str(pkt)) yes_ports = set(of_ports).difference([ingress_port]) testutils.receive_pkt_check(self.dataplane, pkt, yes_ports, [ingress_port], self, pa_logger)
def runTest(self): vlan_tags=[{'type': 0x8100, 'vid': 3, 'pcp': 1}] mpls_tags=[{'type': 0x8847, 'label': 22, 'tc': 2, 'ttl': 48}] ing_port = exact_port_map.keys()[0] egr_port = exact_port_map.keys()[1] #"clear swtich;" testutils.delete_all_flows(self.controller, self.logger) "make test packet;" pkt = testutils.simple_tcp_packet(vlan_tags = vlan_tags, mpls_tags = mpls_tags) match_ls = testutils.packet_to_exact_flow_match(pkt = pkt, table_id = testutils.EX_ACL_TABLE, ing_port = ing_port) exact_table_goto_table(self, testutils.EX_ACL_TABLE, testutils.EX_L2_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match(pkt = pkt, table_id = testutils.EX_L2_TABLE, ing_port = ing_port) exact_table_goto_table(self, testutils.EX_L2_TABLE, testutils.EX_VLAN_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match(pkt = pkt, table_id = testutils.EX_VLAN_TABLE, ing_port = ing_port) exact_table_goto_table(self, testutils.EX_VLAN_TABLE, testutils.EX_MPLS_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match(pkt = pkt, table_id = testutils.EX_MPLS_TABLE, ing_port = ing_port) exact_table_goto_table(self, testutils.EX_MPLS_TABLE, testutils.EX_L3_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match(pkt = pkt, table_id = testutils.EX_L3_TABLE, ing_port = ing_port) exact_table_output(self, testutils.EX_L3_TABLE, match_ls, egr_port = egr_port) testutils.do_barrier(self.controller) "send a packet from ing_port " self.dataplane.send(ing_port, str(pkt)) "poll from the egr_port port" (port_rec, pkt_rec, _) = self.dataplane.poll(port_number=egr_port, timeout=1) self.assertTrue(pkt_rec is not None,"rec none packets") #print("++++++++++++++++++++++rcv_pkt++++++++++++++++++++++") #if pkt_rec is None: # print(str(pkt_rec)) #else: # print(str(pkt_rec).encode('hex')) self.assertEqual(str(pkt), str(pkt_rec), 'retruned pkt not equal to the original pkt')
def runTest(self): port_in = exact_port_map.keys()[0] egr_port = exact_port_map.keys()[1] #"clear swtich;" testutils.delete_all_flows(self.controller, self.logger) "make test packet;" pkt = testutils.simple_tcp_packet(dl_src='00:01:02:03:04:05', dl_dst='00:06:07:08:09:0a') match_ls = testutils.packet_to_exact_flow_match(pkt = pkt, table_id = testutils.EX_ACL_TABLE, ing_port = port_in) exact_table_goto_table(self, testutils.EX_ACL_TABLE, testutils.EX_L2_TABLE, match_ls) match_ls = testutils.packet_to_exact_flow_match(pkt = pkt, table_id = testutils.EX_L2_TABLE, ing_port = port_in) exact_table_output(self, testutils.EX_L2_TABLE, match_ls, egr_port = egr_port) testutils.do_barrier(self.controller) "send a packet from port_in " self.dataplane.send(port_in, str(pkt)) "poll from the egr_port port" (port_rec, pkt_rec, _) = self.dataplane.poll(port_number=egr_port, timeout=1) #print( str(pkt_rec).encode('hex')) self.assertTrue(pkt_rec is not None,"rec none packets") self.assertEqual(str(pkt), str(pkt_rec), 'retruned pkt not equal to the original pkt')
def runTest(self): 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): 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 send_ctrl_exp_error(self, msg, log = '', type = 0, code = 0): group_logger.info('Sending message ' + log) group_logger.debug(msg.show()) rv = self.controller.message_send(msg) self.assertTrue(rv != -1, 'Error sending!') group_logger.info('Waiting for error messages...') (response, raw) = self.controller.poll(ofp.OFPT_ERROR, 1) self.assertTrue(response is not None, 'Did not receive an error message') self.assertEqual(response.header.type, ofp.OFPT_ERROR, 'Did not receive an error message') if type != 0: self.assertEqual(response.type, type, 'Did not receive a ' + str(type) + ' type error message') if code != 0: self.assertEqual(response.code, code, 'Did not receive a ' + str(code) + ' code error message') testutils.do_barrier(self.controller);
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): """ 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): global pa_port_map of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") rc = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rc, 0, "Failed to delete all flows") pkt = testutils.simple_tcp_packet() match = parse.packet_to_flow_match(pkt) match.wildcards &= ~ofp.OFPFW_IN_PORT self.assertTrue(match is not None, "Could not generate flow match from pkt") act = action.action_output() ingress_port = of_ports[0]; egress_port = of_ports[1]; pa_logger.info("Ingress " + str(ingress_port) + " to egress " + str(egress_port)) match.in_port = ingress_port flow_mod_msg = message.flow_mod() flow_mod_msg.match = match flow_mod_msg.command = ofp.OFPFC_ADD flow_mod_msg.cookie = random.randint(0,9007199254740992) flow_mod_msg.buffer_id = 0xffffffff flow_mod_msg.idle_timeout = 1 act.port = egress_port #pdb.set_trace() inst = instruction.instruction_apply_actions() self.assertTrue(inst.actions.add(act), "Could not add action") self.assertTrue(flow_mod_msg.instructions.add(inst), "Could not add action") stat_req = message.flow_stats_request() stat_req.match = match stat_req.table_id = 0xff stat_req.out_port = ofp.OFPP_ANY; stat_req.out_group = ofp.OFPG_ANY; testutils.do_barrier(self.controller) pa_logger.info("Sending stats request (before flow_mod insert)") rv = self.controller.message_send(stat_req) self.assertTrue(rv != -1, "Error sending flow stat req") testutils.do_barrier(self.controller) (empty_response, _) = self.controller.poll(ofp.OFPT_STATS_REPLY, 2) self.assertTrue(empty_response, "No flow_stats reply (expected empty flow_stats)") self.assertEqual(len(empty_response.stats),0) pa_logger.info("Inserting flow") rv = self.controller.message_send(flow_mod_msg) 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)) (rcv_port, rcv_pkt, _) = self.dataplane.poll(timeout=2) self.assertTrue(rcv_pkt is not None, "Did not receive packet") pa_logger.debug("Packet len " + str(len(pkt)) + " in on " + str(rcv_port)) self.assertEqual(rcv_port, egress_port, "Unexpected receive port") self.assertEqual(str(pkt), str(rcv_pkt), 'Response packet does not match send packet') pa_logger.info("Sending stats request") rv = self.controller.message_send(stat_req) self.assertTrue(rv != -1, "Error sending flow stat req") testutils.do_barrier(self.controller) (response, _) = self.controller.poll(ofp.OFPT_STATS_REPLY, 2) self.assertTrue(response, "No Flow_stats reply") #print "YYY: Stats reply is \n%s" % (response.show()) self.assertEqual(len(response.stats), 1, "Did not receive flow stats reply") self.assertEqual(response.stats[0].packet_count,1) self.assertEqual(response.stats[0].byte_count,len(rcv_pkt))
def runTest(self): of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 2, "Not enough ports for test") # Clear flow table rv = testutils.initialize_table_config(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to initialize table config") rv = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rv, 0, "Failed to delete all flows") # Set up first match match = ofp.ofp_match() match.length = ofp.OFPMT_STANDARD_LENGTH testutils.wildcard_all_set(match) match.wildcards -= ofp.OFPFW_DL_TYPE match.nw_src_mask = 0 # Match nw_src match.dl_type = 0x800 match.nw_src = parse.parse_ip("192.168.1.10") act = action.action_output() act.port = of_ports[0] request = message.flow_mod() request.match = match request.buffer_id = 0xffffffff request.table_id = 0 inst = instruction.instruction_write_actions() self.assertTrue(inst.actions.add(act), "Could not add action") self.assertTrue(request.instructions.add(inst), "Could not add inst1") inst = instruction.instruction_goto_table() inst.table_id = 1 self.assertTrue(request.instructions.add(inst), "Could not add inst2") pa_logger.info("Inserting flow 1") rv = self.controller.message_send(request) # pa_logger.debug(request.show()) self.assertTrue(rv != -1, "Error installing flow mod") # Set up second 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 = 0x800 match.nw_proto = 6 # TCP match.tp_src = 80 act = action.action_output() act.port = of_ports[1] request = message.flow_mod() request.match = match request.buffer_id = 0xffffffff request.table_id = 1 inst = instruction.instruction_write_actions() self.assertTrue(inst.actions.add(act), "Could not add action") self.assertTrue(request.instructions.add(inst), "Could not add inst3") pa_logger.info("Inserting flow 2") # pa_logger.debug(request.show()) rv = self.controller.message_send(request) self.assertTrue(rv != -1, "Error installing flow mod") testutils.do_barrier(self.controller) # Generate a packet matching only flow 1; rcv on port[0] pkt = testutils.simple_tcp_packet(ip_src='192.168.1.10', tcp_sport=10) self.dataplane.send(of_ports[2], str(pkt)) (rcv_port, rcv_pkt, _) = self.dataplane.poll(timeout=5) self.assertTrue(rcv_pkt is not None, "Did not receive packet") pa_logger.debug("Packet len " + str(len(rcv_pkt)) + " in on " + str(rcv_port)) self.assertEqual(rcv_port, of_ports[0], "Unexpected receive port") # Generate a packet matching both flow 1 and flow 2; rcv on port[1] pkt = testutils.simple_tcp_packet(ip_src='192.168.1.10', tcp_sport=80) self.dataplane.send(of_ports[2], str(pkt)) (rcv_port, rcv_pkt, _) = self.dataplane.poll(timeout=5) self.assertTrue(rcv_pkt is not None, "Did not receive packet") pa_logger.debug("Packet len " + str(len(rcv_pkt)) + " in on " + str(rcv_port)) self.assertEqual(rcv_port, of_ports[1], "Unexpected receive port")
def runTest(self): global pa_port_map of_ports = pa_port_map.keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") rc = testutils.delete_all_flows(self.controller, pa_logger) self.assertEqual(rc, 0, "Failed to delete all flows") pkt = testutils.simple_tcp_packet() match = parse.packet_to_flow_match(pkt) match.wildcards &= ~ofp.OFPFW_IN_PORT self.assertTrue(match is not None, "Could not generate flow match from pkt") act = action.action_output() ingress_port = of_ports[0] egress_port = of_ports[1] pa_logger.info("Ingress " + str(ingress_port) + " to egress " + str(egress_port)) match.in_port = ingress_port flow_mod_msg = message.flow_mod() flow_mod_msg.match = match flow_mod_msg.command = ofp.OFPFC_ADD flow_mod_msg.cookie = random.randint(0, 9007199254740992) flow_mod_msg.buffer_id = 0xffffffff flow_mod_msg.idle_timeout = 1 act.port = egress_port #pdb.set_trace() inst = instruction.instruction_apply_actions() self.assertTrue(inst.actions.add(act), "Could not add action") self.assertTrue(flow_mod_msg.instructions.add(inst), "Could not add action") stat_req = message.flow_stats_request() stat_req.match = match stat_req.table_id = 0xff stat_req.out_port = ofp.OFPP_ANY stat_req.out_group = ofp.OFPG_ANY testutils.do_barrier(self.controller) pa_logger.info("Sending stats request (before flow_mod insert)") rv = self.controller.message_send(stat_req) self.assertTrue(rv != -1, "Error sending flow stat req") testutils.do_barrier(self.controller) (empty_response, _) = self.controller.poll(ofp.OFPT_STATS_REPLY, 2) self.assertTrue(empty_response, "No flow_stats reply (expected empty flow_stats)") self.assertEqual(len(empty_response.stats), 0) pa_logger.info("Inserting flow") rv = self.controller.message_send(flow_mod_msg) 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)) (rcv_port, rcv_pkt, _) = self.dataplane.poll(timeout=2) self.assertTrue(rcv_pkt is not None, "Did not receive packet") pa_logger.debug("Packet len " + str(len(pkt)) + " in on " + str(rcv_port)) self.assertEqual(rcv_port, egress_port, "Unexpected receive port") self.assertEqual(str(pkt), str(rcv_pkt), 'Response packet does not match send packet') pa_logger.info("Sending stats request") rv = self.controller.message_send(stat_req) self.assertTrue(rv != -1, "Error sending flow stat req") testutils.do_barrier(self.controller) (response, _) = self.controller.poll(ofp.OFPT_STATS_REPLY, 2) self.assertTrue(response, "No Flow_stats reply") #print "YYY: Stats reply is \n%s" % (response.show()) self.assertEqual(len(response.stats), 1, "Did not receive flow stats reply") self.assertEqual(response.stats[0].packet_count, 1) self.assertEqual(response.stats[0].byte_count, len(rcv_pkt))
def runTest(self): #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)