def runTest(self): # Construct packet to send to dataplane # Send packet to dataplane # Poll controller with expect message type packet in of_ports = testutils.clear_switch(self, basic_port_map.keys(), basic_logger) # These will get put into function outpkt = testutils.simple_tcp_packet() of_ports = basic_port_map.keys() of_ports.sort() for dp_port in of_ports: msg = message.packet_out() msg.in_port = ofp.OFPP_CONTROLLER msg.data = str(outpkt) act = action.action_output() act.port = dp_port self.assertTrue(msg.actions.add(act), 'Could not add action to msg') basic_logger.info("PacketOut to: " + str(dp_port)) testutils.ofmsg_send(self, msg) (of_port, pkt, _) = self.dataplane.poll(timeout=1) self.assertTrue(pkt is not None, 'Packet not received') basic_logger.info("PacketOut: got pkt from " + str(of_port)) if of_port is not None: self.assertEqual(of_port, dp_port, "Unexpected receive port") self.assertEqual(str(outpkt), str(pkt), 'Response packet does not match send packet')
def runTest(self): # Construct packet to send to dataplane # Send packet to dataplane # Poll controller with expect message type packet in rc = delete_all_flows(self.controller, basic_logger) self.assertEqual(rc, 0, "Failed to delete all flows") # These will get put into function outpkt = simple_tcp_packet() of_ports = basic_port_map.keys() of_ports.sort() for dp_port in of_ports: msg = message.packet_out() 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, pkt_time) = 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): # Construct packet to send to dataplane # Send packet to dataplane # Poll controller with expect message type packet in rc = delete_all_flows(self.controller, basic_logger) self.assertEqual(rc, 0, "Failed to delete all flows") # These will get put into function of_ports = basic_port_map.keys() random.shuffle(of_ports) for num_ports in range(1,len(of_ports)+1): for outpkt, opt in [ (simple_tcp_packet(), "simple TCP packet"), (simple_eth_packet(), "simple Ethernet packet"), (simple_eth_packet(pktlen=40), "tiny Ethernet packet")]: dp_ports = of_ports[0:num_ports] basic_logger.info("PKT OUT test with " + opt + ", ports " + str(dp_ports)) msg = message.packet_out() msg.data = str(outpkt) act = action.action_output() for i in range(0,num_ports): act.port = dp_ports[i] self.assertTrue(msg.actions.add(act), 'Could not add action to msg') basic_logger.info("PacketOut to: " + str(dp_ports)) rv = self.controller.message_send(msg) self.assertTrue(rv == 0, "Error sending out message") receive_pkt_check(self.dataplane, outpkt, dp_ports, set(of_ports).difference(dp_ports), self, basic_logger, basic_config)
def runTest(self): logging = get_logger() logging.info("Runnign Grp90No150 testcase") of_ports = config["port_map"].keys() of_ports.sort() self.assertTrue(len(of_ports) >= 1, "Not enough ports for test") msg = message.packet_out() msg.bufer_id = -1 msg.in_port = ofp.OFPP_NONE act = action.action_output() act.port = of_ports[0] msg.actions.add(act) pkt = simple_tcp_packet() msg.data = str(pkt) self.controller.message_send(msg) error, _ = self.controller.poll(exp_msg=ofp.OFPT_ERROR) if error: msg.in_port = ofp.OFPP_CONTROLLER self.controller.message_send(msg) error, _ = self.controller.poll(exp_msg=ofp.OFPT_ERROR) self.assertIsNone( error, "Error sending out packet out message.Got OFPT_ERROR") logging.info("Packet Out sent with in_port as OFPP_CONTROLLER") receive_pkt_check(self.dataplane, pkt, [of_ports[0]], set(of_ports).difference([of_ports[0]]), self)
def runTest(self): logging = get_logger() logging.info("Running Grp100No100 BadRequestBufferUnknown test") of_ports = config["port_map"].keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") msg = message.packet_out() msg.in_port = ofp.OFPP_CONTROLLER msg.buffer_id = 173 #Random buffer_id act = action.action_output() act.port = of_ports[1] self.assertTrue(msg.actions.add(act), 'Could not add action to msg') logging.info("PacketOut to: " + str(of_ports[1])) rv = self.controller.message_send(msg) self.assertTrue(rv == 0, "Error sending out message") (response, pkt) = self.controller.poll(exp_msg=ofp.OFPT_ERROR, timeout=5) self.assertTrue(response is not None, 'Switch did not reply with error messge') self.assertTrue(response.type==ofp.OFPET_BAD_REQUEST, 'Message field type is not OFPET_BAD_REQUEST') self.assertTrue(response.code==ofp.OFPBRC_BUFFER_UNKNOWN, 'Message field code is not OFPBRC_BUFFER_UNKNOWN')
def runTest(self): logging = get_logger() logging.info("Running Grp70No60 Forward_Table test") of_ports = config["port_map"].keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") #Clear switch state rv = delete_all_flows(self.controller) self.assertEqual(rv, 0, "Failed to delete all flows") logging.info("Insert a flow F with output action port set to some egress_port") logging.info("Send packet out message (matching flow F) with action.port = OFP.TABLE") logging.info("Expecting packet on the egress_port") #Insert a all wildcarded flow (pkt,match) = wildcard_all(self,of_ports) #Create a packet out message pkt_out =message.packet_out(); pkt_out.data = str(pkt) pkt_out.in_port = of_ports[0] act = action.action_output() act.port = ofp.OFPP_TABLE pkt_out.actions.add(act) rv = self.controller.message_send(pkt_out) self.assertTrue(rv == 0, "Error sending out message") #Verifying packet out message recieved on the expected dataplane port. (of_port, pkt, pkt_time) = self.dataplane.poll(port_number=of_ports[1], exp_pkt=pkt,timeout=3) self.assertTrue(pkt is not None, 'Packet not received')
def runTest(self): # Construct packet to send to dataplane # Send packet to dataplane # Poll controller with expect message type packet in rc = delete_all_flows(self.controller) self.assertEqual(rc, 0, "Failed to delete all flows") # These will get put into function of_ports = config["port_map"].keys() random.shuffle(of_ports) for num_ports in range(1, len(of_ports) + 1): for outpkt, opt in [ (simple_tcp_packet(), "simple TCP packet"), (simple_eth_packet(), "simple Ethernet packet"), (simple_eth_packet(pktlen=40), "tiny Ethernet packet") ]: dp_ports = of_ports[0:num_ports] logging.info("PKT OUT test with " + opt + ", ports " + str(dp_ports)) msg = message.packet_out() msg.data = str(outpkt) act = action.action_output() for i in range(0, num_ports): act.port = dp_ports[i] self.assertTrue(msg.actions.add(act), 'Could not add action to msg') logging.info("PacketOut to: " + str(dp_ports)) rv = self.controller.message_send(msg) self.assertTrue(rv == 0, "Error sending out message") receive_pkt_check(self.dataplane, outpkt, dp_ports, set(of_ports).difference(dp_ports), self)
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): logging = get_logger() logging.info("Running Grp20No70 Packet_Out test") of_ports = config["port_map"].keys() of_ports.sort() #Clear Switch state rc = delete_all_flows(self.controller) self.assertEqual(rc, 0, "Failed to delete all flows") logging.info("Sending a packet-out for each dataplane port") logging.info("Expecting the packet on appropriate dataplane port") for dp_port in of_ports: for outpkt, opt in [ (simple_tcp_packet(), "simple TCP packet"), (simple_eth_packet(), "simple Ethernet packet"), (simple_eth_packet(pktlen=40), "tiny Ethernet packet")]: msg = message.packet_out() msg.in_port = ofp.OFPP_NONE msg.data = str(outpkt) act = action.action_output() act.port = dp_port self.assertTrue(msg.actions.add(act), 'Could not add action to msg') logging.info("PacketOut to: port " + str(dp_port)) rv =self.controller.message_send(msg) self.assertTrue(rv == 0, "Error sending out message") error, _= self.controller.poll(exp_msg=ofp.OFPT_ERROR) if error: msg.in_port = ofp.OFPP_CONTROLLER self.controller.message_send(msg) error, _ =self.controller.poll(exp_msg=ofp.OFPT_ERROR) self.assertIsNone(error, "Could Not send packet out message.got OFPT_ERROR") logging.info("Packet out with in_port OFPP.CONTROLLER") exp_pkt_arg = None exp_port = None if config["relax"]: exp_pkt_arg = outpkt exp_port = dp_port (of_port, pkt, pkt_time) = self.dataplane.poll(timeout=2, port_number=exp_port, exp_pkt=exp_pkt_arg) self.assertTrue(pkt is not None, 'Packet not received on the dataplane port') logging.info("PacketOut: got %s pkt on port " % opt + str(of_port)) if of_port is not None: self.assertEqual(of_port, dp_port, "Unexpected receive port") if not dataplane.match_exp_pkt(outpkt, pkt): logging.debug("Sent %s" % format_packet(outpkt)) logging.debug("Resp %s" % format_packet( str(pkt)[:len(str(outpkt))])) self.assertEqual(str(outpkt), str(pkt)[:len(str(outpkt))], 'Response packet does not match send packet')
def runTest(self): # Set up flow to send from port 1 to port 2 and copy to CPU # Test parameter gives LB port base (assumes consecutive) lb_port = test_param_get('lb_port', default=1) barrier_count = test_param_get('barrier_count', default=10) # Set controller to filter packet ins self.controller.filter_packet_in = True self.controller.pkt_in_filter_limit = 10 pkt = simple_tcp_packet() match = packet_to_flow_match(self, pkt) match.wildcards &= ~ofp.OFPFW_IN_PORT match.in_port = lb_port act = action.action_output() act.port = lb_port + 1 request = message.flow_mod() request.match = match request.hard_timeout = 2 * barrier_count request.buffer_id = 0xffffffff self.assertTrue(request.actions.add(act), "Could not add action") act = action.action_output() act.port = ofp.OFPP_CONTROLLER self.assertTrue(request.actions.add(act), "Could not add action") rv = self.controller.message_send(request) self.assertTrue(rv != -1, "Error installing flow mod") self.assertEqual(do_barrier(self.controller), 0, "Barrier failed") # Create packet out and send to port lb_port + 1 msg = message.packet_out() msg.in_port = lb_port msg.data = str(pkt) act = action.action_output() act.port = lb_port + 1 self.assertTrue(msg.actions.add(act), 'Could not add action to msg') logging.info("Sleeping before starting storm") time.sleep(1) # Root causing issue with fast disconnects logging.info("Sending packet out to %d" % (lb_port + 1)) rv = self.controller.message_send(msg) self.assertTrue(rv == 0, "Error sending out message") for idx in range(0, barrier_count): self.assertEqual(do_barrier(self.controller), 0, "Barrier failed") # To do: Add some interesting functionality here logging.info("Barrier %d completed" % idx) # Clear the flow table when done logging.debug("Deleting all flows from switch") rc = delete_all_flows(self.controller) self.assertEqual(rc, 0, "Failed to delete all flows")
def runTest(self): # Set up flow to send from port 1 to port 2 and copy to CPU # Test parameter gives LB port base (assumes consecutive) lb_port = test_param_get(self.config, 'lb_port', default=1) barrier_count = test_param_get(self.config, 'barrier_count', default=10) # Set controller to filter packet ins self.controller.filter_packet_in = True self.controller.pkt_in_filter_limit = 10 pkt = simple_tcp_packet() match = packet_to_flow_match(self, pkt) match.wildcards &= ~ofp.OFPFW_IN_PORT match.in_port = lb_port act = action.action_output() act.port = lb_port + 1 request = message.flow_mod() request.match = match request.hard_timeout = 2 * barrier_count request.buffer_id = 0xffffffff self.assertTrue(request.actions.add(act), "Could not add action") act = action.action_output() act.port = ofp.OFPP_CONTROLLER self.assertTrue(request.actions.add(act), "Could not add action") rv = self.controller.message_send(request) self.assertTrue(rv != -1, "Error installing flow mod") self.assertEqual(do_barrier(self.controller), 0, "Barrier failed") # Create packet out and send to port lb_port + 1 msg = message.packet_out() msg.data = str(pkt) act = action.action_output() act.port = lb_port + 1 self.assertTrue(msg.actions.add(act), 'Could not add action to msg') load_logger.info("Sleeping before starting storm") time.sleep(1) # Root causing issue with fast disconnects load_logger.info("Sending packet out to %d" % (lb_port + 1)) rv = self.controller.message_send(msg) self.assertTrue(rv == 0, "Error sending out message") for idx in range(0, barrier_count): self.assertEqual(do_barrier(self.controller), 0, "Barrier failed") # To do: Add some interesting functionality here load_logger.info("Barrier %d completed" % idx) # Clear the flow table when done load_logger.debug("Deleting all flows from switch") rc = delete_all_flows(self.controller, load_logger) self.assertEqual(rc, 0, "Failed to delete all flows")
def runTest(self): of_logger.info("Running Packet_Out test") of_ports = of_port_map.keys() of_ports.sort() #Clear Switch state rc = delete_all_flows(self.controller, of_logger) self.assertEqual(rc, 0, "Failed to delete all flows") of_logger.info("Sending a packet-out for each dataplane port") of_logger.info("Expecting the packet on appropriate dataplane port") for dp_port in of_ports: for outpkt, opt in [ (simple_tcp_packet(), "simple TCP packet"), (simple_eth_packet(), "simple Ethernet packet"), (simple_eth_packet(pktlen=40), "tiny Ethernet packet") ]: msg = message.packet_out() msg.data = str(outpkt) act = action.action_output() act.port = dp_port self.assertTrue(msg.actions.add(act), 'Could not add action to msg') of_logger.info("PacketOut to: " + str(dp_port)) rv = self.controller.message_send(msg) self.assertTrue(rv == 0, "Error sending out message") exp_pkt_arg = None exp_port = None if of_config["relax"]: exp_pkt_arg = outpkt exp_port = dp_port (of_port, pkt, pkt_time) = self.dataplane.poll(timeout=2, port_number=exp_port, exp_pkt=exp_pkt_arg) self.assertTrue(pkt is not None, 'Packet not received') of_logger.info("PacketOut: got pkt from " + str(of_port)) if of_port is not None: self.assertEqual(of_port, dp_port, "Unexpected receive port") if not dataplane.match_exp_pkt(outpkt, pkt): of_logger.debug("Sent %s" % format_packet(outpkt)) of_logger.debug("Resp %s" % format_packet(str(pkt)[:len(str(outpkt))])) self.assertEqual(str(outpkt), str(pkt)[:len(str(outpkt))], 'Response packet does not match send packet')
def runTest(self): # Construct packet to send to dataplane # Send packet to dataplane # Poll controller with expect message type packet in rc = delete_all_flows(self.controller, basic_logger) self.assertEqual(rc, 0, "Failed to delete all flows") # These will get put into function of_ports = basic_port_map.keys() of_ports.sort() for dp_port in of_ports: for outpkt, opt in [ (simple_tcp_packet(), "simple TCP packet"), (simple_eth_packet(), "simple Ethernet packet"), (simple_eth_packet(pktlen=40), "tiny Ethernet packet") ]: basic_logger.info("PKT OUT test with %s, port %s" % (opt, dp_port)) msg = message.packet_out() 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") exp_pkt_arg = None exp_port = None if basic_config["relax"]: exp_pkt_arg = outpkt exp_port = dp_port (of_port, pkt, pkt_time) = self.dataplane.poll(port_number=exp_port, exp_pkt=exp_pkt_arg) 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") if not dataplane.match_exp_pkt(outpkt, pkt): basic_logger.debug("Sent %s" % format_packet(outpkt)) basic_logger.debug( "Resp %s" % format_packet(str(pkt)[:len(str(outpkt))])) self.assertEqual(str(outpkt), str(pkt)[:len(str(outpkt))], 'Response packet does not match send packet')
def runTest(self): of_logger.info("Running Packet_Out test") of_ports = of_port_map.keys() of_ports.sort() #Clear Switch state rc = delete_all_flows(self.controller, of_logger) self.assertEqual(rc, 0, "Failed to delete all flows") of_logger.info("Sending a packet-out for each dataplane port") of_logger.info("Expecting the packet on appropriate dataplane port") for dp_port in of_ports: for outpkt, opt in [ (simple_tcp_packet(), "simple TCP packet"), (simple_eth_packet(), "simple Ethernet packet"), (simple_eth_packet(pktlen=40), "tiny Ethernet packet")]: msg = message.packet_out() msg.data = str(outpkt) act = action.action_output() act.port = dp_port self.assertTrue(msg.actions.add(act), 'Could not add action to msg') of_logger.info("PacketOut to: " + str(dp_port)) rv = self.controller.message_send(msg) self.assertTrue(rv == 0, "Error sending out message") exp_pkt_arg = None exp_port = None if of_config["relax"]: exp_pkt_arg = outpkt exp_port = dp_port (of_port, pkt, pkt_time) = self.dataplane.poll(timeout=2, port_number=exp_port, exp_pkt=exp_pkt_arg) self.assertTrue(pkt is not None, 'Packet not received') of_logger.info("PacketOut: got pkt from " + str(of_port)) if of_port is not None: self.assertEqual(of_port, dp_port, "Unexpected receive port") if not dataplane.match_exp_pkt(outpkt, pkt): of_logger.debug("Sent %s" % format_packet(outpkt)) of_logger.debug("Resp %s" % format_packet( str(pkt)[:len(str(outpkt))])) self.assertEqual(str(outpkt), str(pkt)[:len(str(outpkt))], 'Response packet does not match send packet')
def runTest(self): # Construct packet to send to dataplane # Send packet to dataplane # Poll controller with expect message type packet in of_ports = testutils.clear_switch(self, basic_port_map.keys(), basic_logger) 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): # Construct packet to send to dataplane # Send packet to dataplane # Poll controller with expect message type packet in rc = delete_all_flows(self.controller) self.assertEqual(rc, 0, "Failed to delete all flows") # These will get put into function of_ports = config["port_map"].keys() of_ports.sort() for dp_port in of_ports: for outpkt, opt in [ (simple_tcp_packet(), "simple TCP packet"), (simple_eth_packet(), "simple Ethernet packet"), (simple_eth_packet(pktlen=40), "tiny Ethernet packet")]: logging.info("PKT OUT test with %s, port %s" % (opt, dp_port)) msg = message.packet_out() msg.in_port = ofp.OFPP_NONE msg.data = str(outpkt) act = action.action_output() act.port = dp_port self.assertTrue(msg.actions.add(act), 'Could not add action to msg') logging.info("PacketOut to: " + str(dp_port)) rv = self.controller.message_send(msg) self.assertTrue(rv == 0, "Error sending out message") exp_pkt_arg = None exp_port = None if config["relax"]: exp_pkt_arg = outpkt exp_port = dp_port (of_port, pkt, pkt_time) = self.dataplane.poll(port_number=exp_port, exp_pkt=exp_pkt_arg) self.assertTrue(pkt is not None, 'Packet not received') logging.info("PacketOut: got pkt from " + str(of_port)) if of_port is not None: self.assertEqual(of_port, dp_port, "Unexpected receive port") if not dataplane.match_exp_pkt(outpkt, pkt): logging.debug("Sent %s" % format_packet(outpkt)) logging.debug("Resp %s" % format_packet( str(pkt)[:len(str(outpkt))])) self.assertEqual(str(outpkt), str(pkt)[:len(str(outpkt))], 'Response packet does not match send packet')
def runTest(self): logging = get_logger() logging.info("Runnign Grp90No150 testcase") of_ports = config["port_map"].keys() of_ports.sort() self.assertTrue(len(of_ports)>=1,"Not enough ports for test") msg = message.packet_out() msg.bufer_id = -1 msg.in_port = ofp.OFPP_NONE act = action.action_output() act.port = of_ports[0] msg.actions.add(act) pkt = simple_tcp_packet() msg.data = str(pkt) self.controller.message_send(msg) receive_pkt_check(self.dataplane,pkt,[of_ports[0]], set(of_ports).difference([of_ports[0]]),self)
def runTest(self): # Construct packet to send to dataplane # Send packet to dataplane # Poll controller with expect message type packet in rc = delete_all_flows(self.controller) self.assertEqual(rc, 0, "Failed to delete all flows") # These will get put into function of_ports = config["port_map"].keys() of_ports.sort() out_count = 0 in_count = 0 xid = 100 for dp_port in of_ports: for outpkt, opt in [ (simple_tcp_packet(), "simple TCP packet"), (simple_eth_packet(), "simple Ethernet packet"), (simple_eth_packet(pktlen=40), "tiny Ethernet packet") ]: logging.info("PKT OUT test with %s, port %s" % (opt, dp_port)) msg = message.packet_out() msg.data = str(outpkt) act = action.action_output() act.port = dp_port self.assertTrue(msg.actions.add(act), 'Could not add action to msg') logging.info("PacketOutLoad to: " + str(dp_port)) for count in range(100): msg.xid = xid xid += 1 rv = self.controller.message_send(msg) self.assertTrue(rv == 0, "Error sending out message") out_count += 1 exp_pkt_arg = None exp_port = None time.sleep(2) while True: (of_port, pkt, pkt_time) = self.dataplane.poll(timeout=0) if pkt is None: break in_count += 1 logging.info("PacketOutLoad Sent %d. Got %d." % (out_count, in_count))
def runTest(self): outpkt = testutils.simple_tcp_packet() dp_port = 3 for i in range(1, 5): msg = message.packet_out() msg.in_port = ofp.OFPP_CONTROLLER msg.data = str(outpkt) act = action.action_output() act.port = i self.assertTrue(msg.actions.add(act), 'Could not add action to msg') rv = self.controller.message_send(msg) (of_port, pkt, _) = self.dataplane.poll(timeout=2) #print('rec port: ' + str(of_port) ) #print(str(pkt).encode("hex")) self.logger.info('rec port: ' + str(of_port) ) self.logger.info(str(pkt).encode("hex"))
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): # Construct packet to send to dataplane # Send packet to dataplane # Poll controller with expect message type packet in rc = delete_all_flows(self.controller) self.assertEqual(rc, 0, "Failed to delete all flows") # These will get put into function of_ports = config["port_map"].keys() of_ports.sort() out_count = 0 in_count = 0 xid = 100 for dp_port in of_ports: for outpkt, opt in [ (simple_tcp_packet(), "simple TCP packet"), (simple_eth_packet(), "simple Ethernet packet"), (simple_eth_packet(pktlen=40), "tiny Ethernet packet"), ]: logging.info("PKT OUT test with %s, port %s" % (opt, dp_port)) msg = message.packet_out() msg.data = str(outpkt) act = action.action_output() act.port = dp_port self.assertTrue(msg.actions.add(act), "Could not add action to msg") logging.info("PacketOutLoad to: " + str(dp_port)) for count in range(100): msg.xid = xid xid += 1 rv = self.controller.message_send(msg) self.assertTrue(rv == 0, "Error sending out message") out_count += 1 exp_pkt_arg = None exp_port = None time.sleep(2) while True: (of_port, pkt, pkt_time) = self.dataplane.poll(timeout=0) if pkt is None: break in_count += 1 logging.info("PacketOutLoad Sent %d. Got %d." % (out_count, in_count))
def runTest(self): outpkt = testutils.simple_tcp_packet() dp_port = 3 for i in range(1, 5): msg = message.packet_out() msg.in_port = ofp.OFPP_CONTROLLER msg.data = str(outpkt) act = action.action_output() act.port = i self.assertTrue(msg.actions.add(act), 'Could not add action to msg') rv = self.controller.message_send(msg) (of_port, pkt, _) = self.dataplane.poll(timeout=2) #print('rec port: ' + str(of_port) ) #print(str(pkt).encode("hex")) self.logger.info('rec port: ' + str(of_port)) self.logger.info(str(pkt).encode("hex"))
def runTest(self): # Construct packet to send to dataplane # Send packet to dataplane # Poll controller with expect message type packet in delete_all_flows(self.controller) # These will get put into function of_ports = config["port_map"].keys() of_ports.sort() out_count = 0 in_count = 0 xid = 100 for dp_port in of_ports: for outpkt, opt in [ (simple_tcp_packet(), "simple TCP packet"), (simple_eth_packet(), "simple Ethernet packet"), (simple_eth_packet(pktlen=40), "tiny Ethernet packet")]: logging.info("PKT OUT test with %s, port %s" % (opt, dp_port)) msg = message.packet_out() msg.in_port = ofp.OFPP_NONE msg.data = str(outpkt) act = action.action_output() act.port = dp_port msg.actions.add(act) logging.info("PacketOutLoad to: " + str(dp_port)) for count in range(100): msg.xid = xid xid += 1 self.controller.message_send(msg) out_count += 1 exp_pkt_arg = None exp_port = None while True: (of_port, pkt, pkt_time) = self.dataplane.poll() if pkt is None: break in_count += 1 logging.info("PacketOutLoad Sent %d. Got %d." % (out_count, in_count))
def runTest(self): logging = get_logger() logging.info("Runnign Grp90No150 testcase") of_ports = config["port_map"].keys() of_ports.sort() self.assertTrue(len(of_ports)>=1,"Not enough ports for test") msg = message.packet_out() msg.bufer_id = -1 msg.in_port = ofp.OFPP_NONE act = action.action_output() act.port = of_ports[0] msg.actions.add(act) pkt = simple_tcp_packet() msg.data = str(pkt) self.controller.message_send(msg) error, _=self.controller.poll(exp_msg=ofp.OFPT_ERROR) if error: msg.in_port=ofp.OFPP_CONTROLLER self.controller.message_send(msg) error, _ = self.controller.poll(exp_msg=ofp.OFPT_ERROR) self.assertIsNone(error, "Error sending out packet out message.Got OFPT_ERROR") logging.info("Packet Out sent with in_port as OFPP_CONTROLLER") receive_pkt_check(self.dataplane,pkt,[of_ports[0]], set(of_ports).difference([of_ports[0]]),self)
def flow_match_test_pktout(parent, ing_port, egr_ports, dl_vlan=-1, pkt=None, exp_pkt=None, action_list=None): """ Packet-out test on single TCP packet @param egr_ports A single port or list of ports Run test sending packet-out to egr_ports. The goal is to test the actions taken on the packet, not the matching which is of course irrelevant. See flow_match_test for parameter descriptions """ if pkt is None: pkt = simple_tcp_packet(dl_vlan_enable=(dl_vlan >= 0), dl_vlan=dl_vlan) msg = message.packet_out() msg.in_port = ing_port msg.data = str(pkt) if action_list is not None: for act in action_list: assert(msg.actions.add(act)) # Set up output action if egr_ports is not None: for egr_port in egr_ports: act = action.action_output() act.port = egr_port assert(msg.actions.add(act)) logging.debug(msg.show()) rv = parent.controller.message_send(msg) parent.assertTrue(rv == 0, "Error sending out message") if exp_pkt is None: exp_pkt = pkt receive_pkt_verify(parent, egr_ports, exp_pkt, ing_port)
def runTest(self): logging = get_logger() logging.info("Running Grp20No70 Packet_Out test") of_ports = config["port_map"].keys() of_ports.sort() #Clear Switch state rc = delete_all_flows(self.controller) self.assertEqual(rc, 0, "Failed to delete all flows") logging.info("Sending a packet-out for each dataplane port") logging.info("Expecting the packet on appropriate dataplane port") for dp_port in of_ports: for outpkt, opt in [ (simple_tcp_packet(), "simple TCP packet"), (simple_eth_packet(), "simple Ethernet packet"), (simple_eth_packet(pktlen=40), "tiny Ethernet packet") ]: msg = message.packet_out() msg.in_port = ofp.OFPP_NONE msg.data = str(outpkt) act = action.action_output() act.port = dp_port self.assertTrue(msg.actions.add(act), 'Could not add action to msg') logging.info("PacketOut to: port " + str(dp_port)) rv = self.controller.message_send(msg) self.assertTrue(rv == 0, "Error sending out message") error, _ = self.controller.poll(exp_msg=ofp.OFPT_ERROR) if error: msg.in_port = ofp.OFPP_CONTROLLER self.controller.message_send(msg) error, _ = self.controller.poll(exp_msg=ofp.OFPT_ERROR) self.assertIsNone( error, "Could Not send packet out message.got OFPT_ERROR") logging.info("Packet out with in_port OFPP.CONTROLLER") exp_pkt_arg = None exp_port = None if config["relax"]: exp_pkt_arg = outpkt exp_port = dp_port (of_port, pkt, pkt_time) = self.dataplane.poll(timeout=2, port_number=exp_port, exp_pkt=exp_pkt_arg) self.assertTrue(pkt is not None, 'Packet not received on the dataplane port') logging.info("PacketOut: got %s pkt on port " % opt + str(of_port)) if of_port is not None: self.assertEqual(of_port, dp_port, "Unexpected receive port") if not dataplane.match_exp_pkt(outpkt, pkt): logging.debug("Sent %s" % format_packet(outpkt)) logging.debug("Resp %s" % format_packet(str(pkt)[:len(str(outpkt))])) self.assertEqual(str(outpkt), str(pkt)[:len(str(outpkt))], 'Response packet does not match send packet')
def runTest(self): logging = get_logger() logging.info("Running Grp100No90 BadRequestBufferUnknown test") of_ports = config["port_map"].keys() of_ports.sort() self.assertTrue(len(of_ports) > 1, "Not enough ports for test") #Setting the max_len parameter pkt=simple_tcp_packet() match = parse.packet_to_flow_match(pkt) self.assertTrue(match is not None, "Could not generate flow match from pkt") flow_mod_msg = message.flow_mod() flow_mod_msg.match = match flow_mod_msg.buffer_id = 0xffffffff flow_mod_msg.command = ofp.OFPFC_ADD act=action.action_output() act.port = ofp.OFPP_CONTROLLER act.max_len = 128 logging.info("Sending flow_mod message..") self.assertTrue(flow_mod_msg.actions.add(act), 'Could not add action to msg') logging.info("PacketOut to: " + str(of_ports[1])) rv = self.controller.message_send(flow_mod_msg) self.assertTrue(rv == 0, "Error sending out message") self.assertEqual(do_barrier(self.controller), 0, "Barrier failed") #Sending a big packet to create a buffer pkt = simple_tcp_packet(pktlen=400,ip_dst="192.168.0.2") data_len = len(pkt) self.dataplane.send(of_ports[1], str(pkt)) (response, pkt) = self.controller.poll(exp_msg=ofp.OFPT_PACKET_IN, timeout=5) if response.buffer_id == 0xffffffff: logging.info("Device was unable to buffer packet.") self.assertEqual(data_len, len(response.data), "PacketIn data field was not equal to original packet. Expected {0}, received {1}".format(data_len, len(response.data))) return #Creating packet out to clear the buffer msg = message.packet_out() msg.buffer_id = response.buffer_id msg.in_port = ofp.OFPP_CONTROLLER act = action.action_output() act.port = of_ports[2] self.assertTrue(msg.actions.add(act), 'Could not add action to msg') logging.info("PacketOut to: " + str(of_ports[2])) rv1 = self.controller.message_send(msg) self.assertTrue(rv1 == 0, "Error sending out message") self.assertEqual(do_barrier(self.controller), 0, "Barrier failed") #Verifying packet out message recieved on the expected dataplane port. (of_port, pkt, pkt_time) = self.dataplane.poll(port_number=of_ports[2], timeout=5) self.assertTrue(pkt is not None, 'Packet not received') #Creating packet out to generate the buffer msg1 = message.packet_out() msg1.buffer_id = response.buffer_id msg1.in_port = ofp.OFPP_CONTROLLER act1 = action.action_output() act1.port = of_ports[2] self.assertTrue(msg1.actions.add(act1), 'Could not add action to msg') logging.info("PacketOut to: " + str(of_ports[2])) rv1 = self.controller.message_send(msg1) self.assertTrue(rv1 == 0, "Error sending out message") self.assertEqual(do_barrier(self.controller), 0, "Barrier failed") #Sending the packet out second time to generate Buffer Empty message logging.info("Waiting for OFPT_ERROR message...") (response, pkt) = self.controller.poll(exp_msg=ofp.OFPT_ERROR, timeout=5) self.assertTrue(response is not None, 'Switch did not reply with error messge') self.assertTrue(response.type==ofp.OFPET_BAD_REQUEST, 'Message field type is not OFPET_BAD_REQUEST') self.assertTrue(response.code==ofp.OFPBRC_BUFFER_EMPTY or response.code==ofp.OFPBRC_BUFFER_UNKNOWN, 'Message field code is not OFPBRC_BUFFER_EMPTY')