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')
