def runTest(self):
table_id = testutils.EX_L2_TABLE
of_ports = exact_port_map.keys()
egr_port1 = of_ports[len(of_ports)-1]
egr_port2 = of_ports[0]
pkt = testutils.simple_tcp_packet(dl_src='99:33:11:11:11:55', dl_dst='33:33:11:11:77:66')
pkt_metadata = {'metadata_val':0x99999999,
'metadata_msk':0xFFFFFFFFFFFFFFFF}
request = testutils.flow_msg_create(self, pkt, pkt_metadata, egr_port = egr_port1, table_id = table_id)
testutils.flow_msg_install(self, request)
#"mod it ,add outport 1"
request_mod = testutils.flow_msg_create(self, pkt, match_fields = request.match_fields, egr_port = egr_port2, table_id = table_id)
request_mod.command = ofp.OFPFC_MODIFY
testutils.ofmsg_send(self, request_mod)
#print(flow_mod.show())
#"read it back;"
stat_req = message.flow_stats_request()
stat_req.buffer_id = 0xffffffff
stat_req.table_id = table_id
stat_req.out_port = ofp.OFPP_ANY
stat_req.out_group = ofp.OFPG_ANY
stat_req.match_fields = request.match_fields
response, _ = self.controller.transact(stat_req, timeout=2)
#print(response.show())
self.assertTrue(isinstance(response,message.flow_stats_reply),"Not a flow_stats_reply")
self.assertEqual(len(response.stats),1, "len of stats is:"+str(len(response.stats)))
self.assertEqual(response.stats[0].instructions.items[0].actions.items[0].port,
request_mod.instructions.items[0].actions.items[0].port,
"action error:"+str(response.stats[0].instructions.items[0].actions.items[0].port))
def runTest(self):
ing_port = flow_mods_port_map.keys()[0]
out_port1 = flow_mods_port_map.keys()[1]
out_port2 = flow_mods_port_map.keys()[2]
pkt = testutils.simple_tcp_packet()
testutils.delete_all_flows(self.controller, self.logger)
fm_orig = testutils.flow_msg_create(self, pkt,
ing_port=ofp.OFPP_ANY,
egr_port=out_port1,
table_id=2)
fm_new = testutils.flow_msg_create(self, pkt,
ing_port=ing_port,
egr_port=out_port2,
table_id=2)
fm_new.command = ofp.OFPFC_MODIFY_STRICT
testutils.ofmsg_send(self, fm_orig)
testutils.ofmsg_send(self, fm_new)
flow_stats = testutils.flow_stats_get(self)
#print(flow_stats.show())
self.assertEqual(len(flow_stats.stats),1,
"Expected only one flow_mod")
#fail to modify and instruction will remain the same
stat = flow_stats.stats[0]
self.assertEqual(stat.match, fm_orig.match)
self.assertEqual(stat.instructions, fm_orig.instructions)
def runTest(self):
table_id = testutils.EX_L2_TABLE
of_ports = exact_port_map.keys()
egr_port = of_ports[0]
pkt = testutils.simple_tcp_packet(dl_src='22:22:22:22:22:22', dl_dst='22:22:22:22:22:22')
pkt_metadata = {'metadata_val':0x1122334455667788,
'metadata_msk':0xFFFFFFFFFFFFFFFF}
request = testutils.flow_msg_create(self, pkt, pkt_metadata, egr_port = egr_port, table_id = table_id)
testutils.flow_msg_install(self, request)
#"delete it"
request_del = testutils.flow_msg_create(self, pkt, match_fields = request.match_fields, egr_port = egr_port, table_id = table_id)
request_del.command = ofp.OFPFC_DELETE
testutils.ofmsg_send(self, request_del)
#'read it back , returns blank;'
stat_req = message.flow_stats_request()
stat_req.buffer_id = 0xffffffff
stat_req.table_id = table_id
stat_req.out_port = ofp.OFPP_ANY
stat_req.out_group = ofp.OFPG_ANY
stat_req.match_fields = request.match_fields
response, _ = self.controller.transact(stat_req, timeout=2)
self.assertTrue(isinstance(response,message.flow_stats_reply),"Not a flow_stats_reply")
self.assertEqual(len(response.stats),0, "len of stats is:"+str(len(response.stats)))
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):
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):
ing_port = flow_mods_port_map.keys()[0]
out_port1 = flow_mods_port_map.keys()[1]
out_port2 = flow_mods_port_map.keys()[2]
pkt = testutils.simple_tcp_packet()
testutils.delete_all_flows(self.controller, self.logger)
fm_orig = testutils.flow_msg_create(self,
pkt,
ing_port=ofp.OFPP_ANY,
egr_port=out_port1,
table_id=2)
fm_new = testutils.flow_msg_create(self,
pkt,
ing_port=ing_port,
egr_port=out_port2,
table_id=2)
fm_new.command = ofp.OFPFC_MODIFY_STRICT
testutils.ofmsg_send(self, fm_orig)
testutils.ofmsg_send(self, fm_new)
flow_stats = testutils.flow_stats_get(self)
#print(flow_stats.show())
self.assertEqual(len(flow_stats.stats), 1,
"Expected only one flow_mod")
#fail to modify and instruction will remain the same
stat = flow_stats.stats[0]
self.assertEqual(stat.match, fm_orig.match)
self.assertEqual(stat.instructions, fm_orig.instructions)
def runTest(self):
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):
ing_port = flow_mods_port_map.keys()[0]
out_port1 = flow_mods_port_map.keys()[1]
out_port2 = flow_mods_port_map.keys()[2]
pkt = testutils.simple_tcp_packet()
testutils.delete_all_flows(self.controller, self.logger)
fm_orig = testutils.flow_msg_create(self, pkt,
ing_port=ing_port,
egr_port=out_port1)
fm_new = testutils.flow_msg_create(self, pkt,
ing_port=ing_port,
egr_port=out_port2)
fm_new.command = ofp.OFPFC_MODIFY_STRICT
rv = self.controller.message_send(fm_orig)
self.assertEqual(rv, 0, "Failed to insert 1st flow_mod")
testutils.do_barrier(self.controller)
rv = self.controller.message_send(fm_new)
testutils.do_barrier(self.controller)
self.assertEqual(rv, 0, "Failed to insert 2nd flow_mod")
flow_stats = testutils.flow_stats_get(self)
self.assertEqual(len(flow_stats.stats),1,
"Expected only one flow_mod")
stat = flow_stats.stats[0]
self.assertEqual(stat.match, fm_new.match)
self.assertEqual(stat.instructions, fm_new.instructions)
def runTest(self):
of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger)
# For making the test simpler...
ing_port = of_ports[0]
egr_port = of_ports[1]
check_expire_tbl0 = False
check_expire_tbl1 = False
# Build the ingress packet
pkt = testutils.simple_tcp_packet(**self.base_pkt_params)
# Set action for the first table
for item_tbl0 in self.start_pkt_params:
tbl0_pkt_params = self.base_pkt_params.copy()
tbl0_pkt_params[item_tbl0] = self.mod_pkt_params[item_tbl0]
act = testutils.action_generate(self, item_tbl0, tbl0_pkt_params)
action_list = [act]
inst_1 = instruction.instruction_apply_actions()
inst_2 = instruction.instruction_goto_table()
inst_2.table_id = 1
inst_list = [inst_1, inst_2]
request0 = testutils.flow_msg_create(self, pkt,
ing_port=ing_port,
instruction_list=inst_list,
action_list=action_list,
check_expire=check_expire_tbl0,
table_id=0)
exp_pkt = testutils.simple_tcp_packet(**tbl0_pkt_params)
request1 = testutils.flow_msg_create(self, exp_pkt,
ing_port=ing_port,
check_expire=check_expire_tbl1,
table_id=1,
egr_port=egr_port)
# Insert two flows
self.logger.debug("Inserting flows: Modify-field: " + item_tbl0)
testutils.flow_msg_install(self, request0)
testutils.flow_msg_install(self, request1)
# Send pkt
self.logger.debug("Send packet: " + str(ing_port) +
" to " + str(egr_port))
self.dataplane.send(ing_port, str(pkt))
#@todo Not all HW supports both pkt and byte counters
#@todo We shouldn't expect the order of coming response..
if check_expire_tbl0:
flow_removed_verify(self, request0, pkt_count=1,
byte_count=pktlen)
if check_expire_tbl1:
flow_removed_verify(self, request1, pkt_count=1,
byte_count=exp_pktlen)
# Receive and verify pkt
testutils.receive_pkt_verify(self, egr_port, exp_pkt)
def runTest(self):
ing_port = flow_mods_port_map.keys()[0]
egr_port = flow_mods_port_map.keys()[1]
table_id = testutils.EX_L3_TABLE
flow_count = 10
testutils.delete_all_flows_one_table(self.controller, self.logger,
table_id)
match_fields_ls = []
ipv6_src_addr = 'fe80::2420:52ff:fe8f:5188'
metadata_val = 0xaa22334455667788
for i in range(flow_count):
match_fields_ls.append(match_list())
match_fields_ls[i].add(match.eth_type(testutils.IPV6_ETHERTYPE))
match_fields_ls[i].add(
match.ipv6_src(ipaddr.IPv6Address(ipv6_src_addr)))
ipv6_dst_addr = 'fe80::2420:52ff:fe8f:' + str(5190 + i)
match_fields_ls[i].add(
match.ipv6_dst(ipaddr.IPv6Address(ipv6_dst_addr)))
match_fields_ls[i].add(match.metadata(metadata_val))
request = testutils.flow_msg_create(
self,
None,
ing_port=ing_port,
match_fields=match_fields_ls[i],
egr_port=egr_port,
table_id=table_id)
testutils.flow_msg_install(self, request, False)
match_fields = match_list()
match_fields.add(match.eth_type(testutils.IPV6_ETHERTYPE))
match_fields.add(match.ipv6_src(ipaddr.IPv6Address(ipv6_src_addr)))
response = testutils.flow_stats_get(self, table_id=table_id)
self.assertTrue(
len(response.stats) == flow_count,
'Did not add all flows successfully! Get table entry num is %d' %
len(response.stats))
request = testutils.flow_msg_create(self,
None,
None,
ing_port,
match_fields,
table_id=table_id)
request.command = ofp.OFPFC_DELETE
testutils.flow_msg_install(self, request, False)
response = testutils.flow_stats_get(self, table_id=table_id)
self.assertTrue(
len(response.stats) == 0,
'Switch did not del the flow entry! Current table entry num is %d'
% len(response.stats))
def runTest(self):
table_id = testutils.EX_L2_TABLE
of_ports = exact_port_map.keys()
egr_port1 = of_ports[len(of_ports) - 1]
egr_port2 = of_ports[0]
pkt = testutils.simple_tcp_packet(dl_src='99:33:11:11:11:55',
dl_dst='33:33:11:11:77:66')
pkt_metadata = {
'metadata_val': 0x99999999,
'metadata_msk': 0xFFFFFFFFFFFFFFFF
}
request = testutils.flow_msg_create(self,
pkt,
pkt_metadata,
egr_port=egr_port1,
table_id=table_id)
testutils.flow_msg_install(self, request)
#"mod it ,add outport 1"
request_mod = testutils.flow_msg_create(
self,
pkt,
match_fields=request.match_fields,
egr_port=egr_port2,
table_id=table_id)
request_mod.command = ofp.OFPFC_MODIFY
testutils.ofmsg_send(self, request_mod)
#print(flow_mod.show())
#"read it back;"
stat_req = message.flow_stats_request()
stat_req.buffer_id = 0xffffffff
stat_req.table_id = table_id
stat_req.out_port = ofp.OFPP_ANY
stat_req.out_group = ofp.OFPG_ANY
stat_req.match_fields = request.match_fields
response, _ = self.controller.transact(stat_req, timeout=2)
#print(response.show())
self.assertTrue(isinstance(response, message.flow_stats_reply),
"Not a flow_stats_reply")
self.assertEqual(len(response.stats), 1,
"len of stats is:" + str(len(response.stats)))
self.assertEqual(
response.stats[0].instructions.items[0].actions.items[0].port,
request_mod.instructions.items[0].actions.items[0].port,
"action error:" +
str(response.stats[0].instructions.items[0].actions.items[0].port))
def runTest(self):
# Config
of_ports = ipv6_port_map.keys()
of_ports.sort()
ing_port = of_ports[0]
egr_port = of_ports[2]
table_id = testutils.WC_ACL_TABLE
# Remove flows
rc = testutils.delete_all_flows(self.controller, ipv6_logger)
self.assertEqual(rc, 0, "Failed to delete all flows")
# Add entry match
pkt = testutils.simple_ipv6_packet(tcp_sport=80, tcp_dport=8080)
request = testutils.flow_msg_create(self,
pkt,
ing_port=ing_port,
egr_port=egr_port,
table_id=table_id)
testutils.flow_msg_install(self, request)
#Send packet
ipv6_logger.info("Sending IPv6 packet to " + str(ing_port))
ipv6_logger.debug("Data: " + str(pkt).encode('hex'))
self.dataplane.send(ing_port, str(pkt))
#Receive packet
exp_pkt = testutils.simple_ipv6_packet(tcp_sport=80, tcp_dport=8080)
testutils.receive_pkt_verify(self, egr_port, exp_pkt)
#Remove flows
rc = testutils.delete_all_flows(self.controller, ipv6_logger)
self.assertEqual(rc, 0, "Failed to delete all flows")
def runTest(self):
of_ports = ipv6_port_map.keys()
of_ports.sort()
ing_port = of_ports[0]
egr_port = of_ports[2]
table_id = testutils.WC_L3_TABLE
# Remove all entries Add entry match all
rc = testutils.delete_all_flows(self.controller, self.logger)
self.assertEqual(rc, 0, "Failed to delete all flows")
rv = testutils.set_table_config(self, table_id)
self.assertEqual(rv, 0, "Failed to set table config")
# Add entry match
pkt = testutils.simple_ipv6_packet()
request = testutils.flow_msg_create(self,
pkt,
ing_port=ing_port,
egr_port=egr_port,
table_id=table_id)
testutils.flow_msg_install(self, request)
#Send packet
self.logger.info("Sending IPv6 packet to " + str(ing_port))
self.logger.debug("Data: " + str(pkt).encode('hex'))
self.dataplane.send(ing_port, str(pkt))
#Receive packet
testutils.receive_pkt_verify(self, egr_port, pkt)
#Remove flows
rc = testutils.delete_all_flows(self.controller, self.logger)
self.assertEqual(rc, 0, "Failed to delete all flows")
def runTest(self):
"""
** 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
"""
of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger)
# Set up first match
testutils.write_goto(self, testutils.WC_ACL_TABLE, testutils.WC_SERV_TABLE)
# Set up second match
testutils.write_goto_output(self, testutils.WC_SERV_TABLE, testutils.EX_L2_TABLE,
of_ports[0], of_ports[2])
# Set up third match, "Empty Instruction"
pkt = testutils.simple_tcp_packet()
request = testutils.flow_msg_create(self, pkt, ing_port = of_ports[2], table_id = testutils.EX_L2_TABLE)
testutils.flow_msg_install(self, request)
# Set up fourth match
testutils.write_output(self, testutils.EX_VLAN_TABLE, of_ports[1])
# Generate a packet matching flow 1, 2, and 3; rcv on port[0]
testutils.reply_check_dp(self, tcp_sport=1234,
ing_port = of_ports[2], egr_port = of_ports[0])
def runTest(self):
of_ports = exact_port_map.keys()
ing_port = of_ports[0]
egr_port = of_ports[1]
table_id = testutils.EX_ACL_TABLE
"clear swtich;"
testutils.delete_all_flows(self.controller, self.logger)
"make test packet;"
pkt = testutils.simple_tcp_packet()
"construct flow entry"
match_ls = testutils.packet_to_exact_flow_match(
pkt, None, table_id, ing_port)
flow_add = testutils.flow_msg_create(self,
pkt,
match_fields=match_ls,
egr_port=egr_port,
table_id=table_id)
testutils.ofmsg_send(self, flow_add)
"read flow back;"
response = testutils.flow_stats_get(self, match_ls, table_id)
self.assertTrue(len(response.stats) != 0, "stats len is 0")
"send a packet from ing_port "
self.dataplane.send(ing_port, str(pkt))
"poll from the egr_port port"
testutils.receive_pkt_verify(self, egr_port, pkt)
def runTest(self):
table_id = testutils.EX_L2_TABLE
of_ports = exact_port_map.keys()
egr_port = of_ports[len(of_ports) - 1]
pkt = testutils.simple_tcp_packet(dl_src='00:22:44:62:9b:1c',
dl_dst='00:13:07:5f:61:ab')
pkt_metadata = {
'metadata_val': 0xaa22334455667788,
'metadata_msk': 0xFFFFFFFFFFFFFFFF
}
request = testutils.flow_msg_create(self,
pkt,
pkt_metadata,
egr_port=egr_port,
table_id=table_id)
request.hard_timeout = 8
request.idle_timeout = 8
testutils.flow_msg_install(self, request)
#"get flow stats"
stat_req = message.flow_stats_request()
stat_req.buffer_id = 0xffffffff
stat_req.table_id = table_id
stat_req.out_port = ofp.OFPP_ANY
stat_req.out_group = ofp.OFPG_ANY
stat_req.match_fields = request.match_fields
response, _ = self.controller.transact(stat_req, timeout=2)
self.assertTrue(isinstance(response, message.flow_stats_reply),
"Not a flow_stats_reply")
self.assertEqual(len(response.stats), 1,
"len of stats is:" + str(len(response.stats)))
def runTest(self):
table_id = testutils.EX_L2_TABLE
of_ports = exact_port_map.keys()
egr_port = of_ports[1]
pkt = testutils.simple_tcp_packet(dl_src='08:02:ff:34:88:99',
dl_dst='22:22:ed:22:5f:1a')
request = testutils.flow_msg_create(self,
pkt,
egr_port=egr_port,
table_id=table_id)
for obj in request.match_fields.tlvs:
if obj.field == ofp.OFPXMT_OFB_METADATA:
obj.value = 0x9922334455667788
request.idle_timeout = 1
request.flags |= ofp.OFPFF_SEND_FLOW_REM
testutils.flow_msg_install(self, request)
#print(request.show())
(response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 3)
self.assertTrue(response is not None,
'Did not receive flow removed message ')
self.assertEqual(request.cookie, response.cookie,
'Cookies do not match')
self.assertEqual(
ofp.OFPRR_IDLE_TIMEOUT, response.reason,
'Flow table entry removal reason is not idle_timeout')
def runTest(self):
of_ports = testutils.clear_switch(self, exact_port_map.keys(),
exact_logger) #zhaoxiuchu
table_id = testutils.EX_L2_TABLE
of_ports = exact_port_map.keys()
egr_port = of_ports[1]
pkt = testutils.simple_tcp_packet(dl_src='08:02:03:04:88:99',
dl_dst='22:22:22:22:22:22')
pkt_metadata = {
'metadata_val': 0xad22332e6f667588,
'metadata_msk': 0xFFFFFFFFFFFFFFFF
}
request = testutils.flow_msg_create(self,
pkt,
pkt_metadata,
egr_port=egr_port,
table_id=table_id)
request.hard_timeout = 1
request.flags |= ofp.OFPFF_SEND_FLOW_REM
testutils.flow_msg_install(self, request)
#print(request.show())
(response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 3)
self.assertTrue(response is not None,
'Did not receive flow removed message ')
self.assertEqual(request.cookie, response.cookie,
'Cookies do not match')
self.assertEqual(
ofp.OFPRR_HARD_TIMEOUT, response.reason,
'Flow table entry removal reason is not idle_timeout')
def runTest(self):
of_ports = pa_port_map.keys()
of_ports.sort()
self.assertTrue(len(of_ports) > 2, "Not enough ports for test")
pkt = testutils.simple_tcp_packet()
for ingress_port in of_ports:
rv = testutils.delete_all_flows(self.controller, pa_logger)
self.assertEqual(rv, 0, "Failed to delete all flows")
pa_logger.info("Ingress " + str(ingress_port) +
" all non-ingress ports")
actions = []
for egress_port in of_ports:
act = action.action_output()
if egress_port == ingress_port:
continue
act.port = egress_port
actions.append(act)
request = testutils.flow_msg_create(self, pkt, ing_port=ingress_port,
action_list=actions, inst_app_flag=testutils.APPLY_ACTIONS_INSTRUCTION)
pa_logger.info("Inserting flow")
testutils.ofmsg_send(self, request)
pa_logger.info("Sending packet to dp port " + str(ingress_port))
self.dataplane.send(ingress_port, str(pkt))
yes_ports = set(of_ports).difference([ingress_port])
testutils.receive_pkt_check(self.dataplane, pkt, yes_ports, [ingress_port],
self, pa_logger)
def runTest(self):
testutils.clear_switch(self,group_port_map,group_logger)
# self.clear_switch()
group_add_msg = \
create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_INDIRECT, group_id = 1, buckets = [
create_bucket(0, 0, 0, [
create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 2000),
create_action(action = ofp.OFPAT_OUTPUT, port = 2)
])
])
self.send_ctrl_exp_noerror(group_add_msg, 'group add')
packet_in = testutils.simple_tcp_packet(tcp_sport=1000)
packet_out = testutils.simple_tcp_packet(tcp_sport=2000)
flow_add_msg = \
testutils.flow_msg_create(self,packet_in,ing_port = 1,action_list = [
create_action(action = ofp.OFPAT_GROUP, group_id = 1)
])
self.send_ctrl_exp_noerror(flow_add_msg, 'flow add')
self.send_data(packet_in, 1)
self.recv_data(2, packet_out)
def runTest(self):
ing_port = flow_mods_port_map.keys()[0]
out_port1 = flow_mods_port_map.keys()[1]
out_port2 = flow_mods_port_map.keys()[2]
pkt = testutils.simple_tcp_packet()
testutils.delete_all_flows(self.controller, self.logger)
fm_orig = testutils.flow_msg_create(self, pkt,
ing_port=ing_port,
egr_port=out_port1)
inst = None
inst = instruction.instruction_write_actions()#instruct is the same, action is different
act = action.action_output()
act.port = out_port2
rv = inst.actions.add(act)
self.assertTrue(rv, "Could not add action" + act.show())
fm_orig.instructions.add(inst)
#print(fm_orig.show())
testutils.ofmsg_send(self, fm_orig)
(response, raw) = self.controller.poll(ofp.OFPT_ERROR, 5)
self.assertTrue(response is not None, 'No error message received')
self.assertEqual(ofp.OFPET_BAD_INSTRUCTION, response.type,
'Error message type mismatch: ' +
str(ofp.OFPET_BAD_INSTRUCTION,) + " != " +
str(response.type))
self.assertEqual(ofp.OFPBIC_UNKNOWN_INST, response.code,
'Error message code mismatch: ' +
str(ofp.OFPBIC_UNKNOWN_INST) + " != " +
str(response.code))
def runTest(self):
of_ports = pa_port_map.keys()
of_ports.sort()
self.assertTrue(len(of_ports) > 1, "Not enough ports for test")
pkt = testutils.simple_tcp_packet()
for ingress_port in of_ports:
rv = testutils.delete_all_flows(self.controller, pa_logger)
self.assertEqual(rv, 0, "Failed to delete all flows")
pa_logger.info("Ingress " + str(ingress_port) + " to all ports")
request = testutils.flow_msg_create(self,
pkt,
ing_port=ingress_port,
egr_port=ofp.OFPP_ALL)
pa_logger.info("Inserting flow")
testutils.ofmsg_send(self, request)
pa_logger.info("Sending packet to dp port " + str(ingress_port))
self.dataplane.send(ingress_port, str(pkt))
yes_ports = set(of_ports).difference([ingress_port])
testutils.receive_pkt_check(self.dataplane, pkt, yes_ports,
[ingress_port], self, pa_logger)
def runTest(self):
ing_port = flow_mods_port_map.keys()[0]
out_port1 = 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):
ing_port = flow_mods_port_map.keys()[0]
out_port1 = ofp.OFPP_ALL
pkt = testutils.simple_tcp_packet()
testutils.delete_all_flows(self.controller, self.logger)
fm_orig = testutils.flow_msg_create(self,
pkt,
ing_port=ing_port,
egr_port=out_port1) #flood
inst = None
inst = instruction.instruction_apply_actions()
act = action.action_output()
act.port = ofp.OFPP_IN_PORT #fwd to ingress
rv = inst.actions.add(act)
self.assertTrue(rv, "Could not add action" + act.show())
fm_orig.instructions.add(inst)
#print(fm_orig.show())
testutils.ofmsg_send(self, fm_orig)
(response, raw) = self.controller.poll(ofp.OFPT_ERROR, 2)
self.assertTrue(response is None, 'Receive error message')
#user sends packet
self.dataplane.send(ing_port, str(pkt))
testutils.do_barrier(self.controller)
#verify pkt
for of_port in flow_mods_port_map.keys():
testutils.receive_pkt_verify(self, of_port, pkt)
def runTest(self):
of_ports = ipv6_port_map.keys()
of_ports.sort()
ing_port = of_ports[0]
egr_port = of_ports[2]
table_id = testutils.WC_L3_TABLE
# Remove all entries Add entry match all
rc = testutils.delete_all_flows(self.controller, self.logger)
self.assertEqual(rc, 0, "Failed to delete all flows")
rv = testutils.set_table_config(self, table_id)
self.assertEqual(rv, 0, "Failed to set table config")
# Add entry match
pkt = testutils.simple_ipv6_packet()
request = testutils.flow_msg_create(self, pkt, ing_port = ing_port, egr_port = egr_port, table_id = table_id)
testutils.flow_msg_install(self, request)
#Send packet
self.logger.info("Sending IPv6 packet to " + str(ing_port))
self.logger.debug("Data: " + str(pkt).encode('hex'))
self.dataplane.send(ing_port, str(pkt))
#Receive packet
testutils.receive_pkt_verify(self, egr_port, pkt)
#Remove flows
rc = testutils.delete_all_flows(self.controller, self.logger)
self.assertEqual(rc, 0, "Failed to delete all flows")
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) > 2, "Not enough ports for test")
pkt = testutils.simple_tcp_packet()
for ingress_port in of_ports:
rv = testutils.delete_all_flows(self.controller, pa_logger)
self.assertEqual(rv, 0, "Failed to delete all flows")
pa_logger.info("Ingress " + str(ingress_port) +
" all non-ingress ports")
actions = []
for egress_port in of_ports:
act = action.action_output()
if egress_port == ingress_port:
continue
act.port = egress_port
actions.append(act)
request = testutils.flow_msg_create(
self,
pkt,
ing_port=ingress_port,
action_list=actions,
inst_app_flag=testutils.APPLY_ACTIONS_INSTRUCTION)
pa_logger.info("Inserting flow")
testutils.ofmsg_send(self, request)
pa_logger.info("Sending packet to dp port " + str(ingress_port))
self.dataplane.send(ingress_port, str(pkt))
yes_ports = set(of_ports).difference([ingress_port])
testutils.receive_pkt_check(self.dataplane, pkt, yes_ports,
[ingress_port], self, pa_logger)
def runTest(self):
of_ports = pa_port_map.keys()
of_ports.sort()
self.assertTrue(len(of_ports) > 1, "Not enough ports for test")
pkt = testutils.simple_tcp_packet()
act_all = action.action_output()
act_all.port = ofp.OFPP_ALL
act_ing = action.action_output()
act_ing.port = ofp.OFPP_IN_PORT
actions = [ act_all, act_ing]
for ingress_port in of_ports:
rv = testutils.delete_all_flows(self.controller, pa_logger)
self.assertEqual(rv, 0, "Failed to delete all flows")
pa_logger.info("Ingress " + str(ingress_port) + " to all ports")
flow_mod = testutils.flow_msg_create(self, pkt,
ing_port=ingress_port,
action_list=actions,
inst_app_flag=testutils.APPLY_ACTIONS_INSTRUCTION
)
pa_logger.info(flow_mod.show())
pa_logger.info("Inserting flow")
testutils.ofmsg_send(self, flow_mod)
pa_logger.info("Sending packet to dp port " + str(ingress_port))
self.dataplane.send(ingress_port, str(pkt))
testutils.receive_pkt_check(self.dataplane, pkt, of_ports, [], self,
pa_logger)
def handleFlow(self, pkttype='TCP'):
of_ports = pa_port_map.keys()
of_ports.sort()
self.assertTrue(len(of_ports) > 1, "Not enough ports for test")
if (pkttype == 'ICMP'):
pkt = testutils.simple_icmp_packet()
table_id = testutils.EX_ICMP_TABLE
else:
pkt = testutils.simple_tcp_packet()
table_id = testutils.WC_ACL_TABLE
for idx in range(len(of_ports)):
rv = testutils.delete_all_flows(self.controller, pa_logger)
self.assertEqual(rv, 0, "Failed to delete all flows")
testutils.set_table_config(self, table_id, ofp.OFPTC_TABLE_MISS_CONTINUE)
ingress_port = of_ports[idx]
egress_port = of_ports[(idx + 1) % len(of_ports)]
pa_logger.info("Ingress " + str(ingress_port) +
" to egress " + str(egress_port))
#controller send flow mod to switch
request = testutils.flow_msg_create(self,pkt, ing_port=ingress_port,
egr_port=egress_port, table_id=table_id)
testutils.flow_msg_install(self, request)
#user send pkt to switch
pa_logger.info("Sending packet to dp port " + str(ingress_port))
self.dataplane.send(ingress_port, str(pkt))
testutils.receive_pkt_verify(self, egress_port, pkt)
def runTest(self):
of_ports = pa_port_map.keys()
of_ports.sort()
self.assertTrue(len(of_ports) > 1, "Not enough ports for test")
pkt = testutils.simple_tcp_packet()
act_all = action.action_output()
act_all.port = ofp.OFPP_ALL
act_ing = action.action_output()
act_ing.port = ofp.OFPP_IN_PORT
actions = [ act_all, act_ing]
for ingress_port in of_ports:
rv = testutils.delete_all_flows(self.controller, pa_logger)
self.assertEqual(rv, 0, "Failed to delete all flows")
pa_logger.info("Ingress " + str(ingress_port) + " to all ports")
flow_mod = testutils.flow_msg_create(self, pkt,
ing_port=ingress_port,
action_list=actions,
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 = flow_mods_port_map.keys()[1]
out_port2 = flow_mods_port_map.keys()[2]
pkt = testutils.simple_tcp_packet()
testutils.delete_all_flows(self.controller, self.logger)
fm_orig = testutils.flow_msg_create(self,
pkt,
ing_port=ing_port,
egr_port=out_port1)
inst = None
inst = instruction.instruction_write_actions(
) #instruct is the same, action is different
act = action.action_output()
act.port = out_port2
rv = inst.actions.add(act)
self.assertTrue(rv, "Could not add action" + act.show())
fm_orig.instructions.add(inst)
#print(fm_orig.show())
testutils.ofmsg_send(self, fm_orig)
(response, raw) = self.controller.poll(ofp.OFPT_ERROR, 5)
self.assertTrue(response is not None, 'No error message received')
self.assertEqual(
ofp.OFPET_BAD_INSTRUCTION, response.type,
'Error message type mismatch: ' +
str(ofp.OFPET_BAD_INSTRUCTION, ) + " != " + str(response.type))
self.assertEqual(
ofp.OFPBIC_UNKNOWN_INST, response.code,
'Error message code mismatch: ' + str(ofp.OFPBIC_UNKNOWN_INST) +
" != " + str(response.code))
def handleFlow(self, pkttype='TCP'):
of_ports = pa_port_map.keys()
of_ports.sort()
self.assertTrue(len(of_ports) > 1, "Not enough ports for test")
if (pkttype == 'ICMP'):
pkt = testutils.simple_icmp_packet()
table_id = testutils.EX_ICMP_TABLE
else:
pkt = testutils.simple_tcp_packet()
table_id = testutils.WC_ACL_TABLE
for idx in range(len(of_ports)):
rv = testutils.delete_all_flows(self.controller, pa_logger)
self.assertEqual(rv, 0, "Failed to delete all flows")
testutils.set_table_config(self, table_id,
ofp.OFPTC_TABLE_MISS_CONTINUE)
ingress_port = of_ports[idx]
egress_port = of_ports[(idx + 1) % len(of_ports)]
pa_logger.info("Ingress " + str(ingress_port) + " to egress " +
str(egress_port))
#controller send flow mod to switch
request = testutils.flow_msg_create(self,
pkt,
ing_port=ingress_port,
egr_port=egress_port,
table_id=table_id)
testutils.flow_msg_install(self, request)
#user send pkt to switch
pa_logger.info("Sending packet to dp port " + str(ingress_port))
self.dataplane.send(ingress_port, str(pkt))
testutils.receive_pkt_verify(self, egress_port, pkt)
def runTest(self):
of_ports = pa_port_map.keys()
of_ports.sort()
self.assertTrue(len(of_ports) > 1, "Not enough ports for test")
pkt = testutils.simple_tcp_packet()
act_all = action.action_output()
act_all.port = ofp.OFPP_ALL
act_ing = action.action_output()
act_ing.port = ofp.OFPP_IN_PORT
actions = [act_all, act_ing]
for ingress_port in of_ports:
rv = testutils.delete_all_flows(self.controller, pa_logger)
self.assertEqual(rv, 0, "Failed to delete all flows")
pa_logger.info("Ingress " + str(ingress_port) + " to all ports")
flow_mod = testutils.flow_msg_create(
self,
pkt,
ing_port=ingress_port,
action_list=actions,
inst_app_flag=testutils.APPLY_ACTIONS_INSTRUCTION)
pa_logger.info(flow_mod.show())
pa_logger.info("Inserting flow")
testutils.ofmsg_send(self, flow_mod)
pa_logger.info("Sending packet to dp port " + str(ingress_port))
self.dataplane.send(ingress_port, str(pkt))
testutils.receive_pkt_check(self.dataplane, pkt, of_ports, [],
self, pa_logger)
def runTest(self):
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):
# Config
of_ports = ipv6_port_map.keys()
of_ports.sort()
ing_port = of_ports[0]
egr_port = of_ports[2]
table_id = testutils.WC_ACL_TABLE
# Remove flows
rc = testutils.delete_all_flows(self.controller, ipv6_logger)
self.assertEqual(rc, 0, "Failed to delete all flows")
# Add entry match
pkt = testutils.simple_ipv6_packet(tcp_sport=80, tcp_dport=8080)
request = testutils.flow_msg_create(self, pkt, ing_port = ing_port, egr_port = egr_port, table_id = table_id)
testutils.flow_msg_install(self, request)
#Send packet
ipv6_logger.info("Sending IPv6 packet to " + str(ing_port))
ipv6_logger.debug("Data: " + str(pkt).encode('hex'))
self.dataplane.send(ing_port, str(pkt))
#Receive packet
exp_pkt = testutils.simple_ipv6_packet(tcp_sport=80, tcp_dport=8080)
testutils.receive_pkt_verify(self, egr_port, exp_pkt)
#Remove flows
rc = testutils.delete_all_flows(self.controller, ipv6_logger)
self.assertEqual(rc, 0, "Failed to delete all flows")
def runExpireTest(self, idle_timeout=0, hard_timeout=0):
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 = delete_all_flows(self.controller, pa_logger)
self.assertEqual(rc, 0, "Failed to delete all flows")
pkt = 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 = pa_config["base_of_port"]
egress_port = (pa_config["base_of_port"] + 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.match = match
#
request = testutils.flow_msg_create(self, pkt, ingress_port, egr_port=egress_port, check_expire=True)
request.cookie = random.randint(0,9007199254740992)
request.buffer_id = 0xffffffff
request.idle_timeout = idle_timeout
request.hard_timeout = hard_timeout
request.flags |= ofp.OFPFF_SEND_FLOW_REM
match = request.match
pa_logger.info("Inserting flow")
rv = self.controller.message_send(request)
self.assertTrue(rv != -1, "Error installing flow mod")
do_barrier(self.controller)
(response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 2)
self.assertTrue(response is not None,
'Did not receive flow removed message ')
self.assertEqual(request.cookie, response.cookie,
'Cookies do not match')
if idle_timeout == 0:
self.assertEqual(ofp.OFPRR_HARD_TIMEOUT, response.reason,
'Flow table entry removal reason is not idle_timeout')
elif hard_timeout == 0:
self.assertEqual(ofp.OFPRR_IDLE_TIMEOUT, response.reason,
'Flow table entry removal reason is not idle_timeout')
self.assertEqual(match, response.match,
'Flow table entry does not match')
def runTest(self):
self.clear_switch()
group_add_msg2 = \
create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 2, buckets = [
create_bucket(0, 0, 0, [
create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 2000),
create_action(action = ofp.OFPAT_OUTPUT, port = 2)
])
])
self.send_ctrl_exp_noerror(group_add_msg2, 'group add 2')
group_add_msg3 = \
create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 3, buckets = [
create_bucket(0, 0, 0, [
create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 3000),
create_action(action = ofp.OFPAT_OUTPUT, port = 3)
]),
create_bucket(0, 0, 0, [
create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 4000),
create_action(action = ofp.OFPAT_OUTPUT, port = 4)
])
])
self.send_ctrl_exp_noerror(group_add_msg3, 'group add 3')
group_add_msg1 = \
create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 1, buckets = [
create_bucket(0, 0, 0, [
create_action(action = ofp.OFPAT_GROUP, group_id = 2),
]),
create_bucket(0, 0, 0, [
create_action(action = ofp.OFPAT_GROUP, group_id = 3),
])
])
self.send_ctrl_exp_noerror(group_add_msg1, 'group add 1')
packet_in = testutils.simple_tcp_packet(tcp_sport=1000)
packet_out1 = testutils.simple_tcp_packet(tcp_sport=2000)
packet_out2 = testutils.simple_tcp_packet(tcp_sport=3000)
packet_out3 = testutils.simple_tcp_packet(tcp_sport=4000)
flow_add_msg = \
testutils.flow_msg_create(self,packet_in,ing_port = 1,action_list = [
create_action(action = ofp.OFPAT_GROUP, group_id = 1)
])
self.send_ctrl_exp_noerror(flow_add_msg, 'flow add')
self.send_data(packet_in, 1)
self.recv_data(2, packet_out1)
self.recv_data(3, packet_out2)
self.recv_data(4, packet_out3)
def runTest(self):
ing_port = flow_mods_port_map.keys()[0]
out_port1 = flow_mods_port_map.keys()[1]
out_port2 = flow_mods_port_map.keys()[2]
pkt = testutils.simple_tcp_packet()
testutils.delete_all_flows(self.controller, self.logger)
fm_orig = testutils.flow_msg_create(self, pkt,
ing_port=ing_port,
egr_port=out_port1)
fm_new = testutils.flow_msg_create(self, pkt,
ing_port=ing_port,
egr_port=out_port2)
fm_new.command = ofp.OFPFC_MODIFY_STRICT
testutils.ofmsg_send(self, fm_orig)
testutils.ofmsg_send(self, fm_new)
flow_stats = testutils.flow_stats_get(self)
self.assertEqual(len(flow_stats.stats),1,
"Expected only one flow_mod")
stat = flow_stats.stats[0]
#self.assertEqual(stat.match_fields, fm_new.match_fields)
self.assertEqual(stat.instructions, fm_new.instructions, "instructions not equal !")
def runTest(self):
table_id = testutils.EX_L2_TABLE
of_ports = exact_port_map.keys()
egr_port = of_ports[0]
pkt = testutils.simple_tcp_packet(dl_src='22:22:22:22:22:22',
dl_dst='22:22:22:22:22:22')
pkt_metadata = {
'metadata_val': 0x1122334455667788,
'metadata_msk': 0xFFFFFFFFFFFFFFFF
}
request = testutils.flow_msg_create(self,
pkt,
pkt_metadata,
egr_port=egr_port,
table_id=table_id)
testutils.flow_msg_install(self, request)
#"delete it"
request_del = testutils.flow_msg_create(
self,
pkt,
match_fields=request.match_fields,
egr_port=egr_port,
table_id=table_id)
request_del.command = ofp.OFPFC_DELETE
testutils.ofmsg_send(self, request_del)
#'read it back , returns blank;'
stat_req = message.flow_stats_request()
stat_req.buffer_id = 0xffffffff
stat_req.table_id = table_id
stat_req.out_port = ofp.OFPP_ANY
stat_req.out_group = ofp.OFPG_ANY
stat_req.match_fields = request.match_fields
response, _ = self.controller.transact(stat_req, timeout=2)
self.assertTrue(isinstance(response, message.flow_stats_reply),
"Not a flow_stats_reply")
self.assertEqual(len(response.stats), 0,
"len of stats is:" + str(len(response.stats)))
def runTest(self):
testutils.clear_switch(self,group_port_map,group_logger)
# self.clear_switch()
group_add_msg = \
create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_SELECT, group_id = 1, buckets = [
create_bucket(1, 0, 0, [
create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 2000),
create_action(action = ofp.OFPAT_OUTPUT, port = 2)
]),
create_bucket(1, 0, 0, [
create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 3000),
create_action(action = ofp.OFPAT_OUTPUT, port = 3)
]),
create_bucket(1, 0, 0, [
create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 4000),
create_action(action = ofp.OFPAT_OUTPUT, port = 4)
])
])
self.send_ctrl_exp_noerror(group_add_msg, 'group add')
packet_in = testutils.simple_tcp_packet(tcp_sport=1000)
packet_out1 = testutils.simple_tcp_packet(tcp_sport=2000)
packet_out2 = testutils.simple_tcp_packet(tcp_sport=3000)
packet_out3 = testutils.simple_tcp_packet(tcp_sport=4000)
flow_add_msg = \
testutils.flow_msg_create(self,packet_in,ing_port = 1,action_list = [
create_action(action = ofp.OFPAT_GROUP, group_id = 1)
])
self.send_ctrl_exp_noerror(flow_add_msg, 'flow add')
self.send_data(packet_in, 1)
recv1 = self.recv_data(2)
recv2 = self.recv_data(3)
recv3 = self.recv_data(4)
self.assertTrue(((recv1 is not None) or (recv2 is not None) or (recv3 is not None)),
"Did not receive a packet")
self.assertTrue(((recv1 is not None) and (recv2 is None) and (recv3 is None)) or \
((recv1 is None) and (recv2 is not None) and (recv3 is None)) or \
((recv1 is None) and (recv2 is None) and (recv3 is not None)),
"Received too many packets")
self.assertTrue(((recv1 is not None) and testutils.pkt_verify(self, recv1, packet_out1)) or \
((recv2 is not None) and testutils.pkt_verify(self, recv2, packet_out2)) or \
((recv3 is not None) and testutils.pkt_verify(self, recv3, packet_out3)),
"Received unexpected packet")
def runTest(self):
ing_port = flow_mods_port_map.keys()[0]
egr_port = flow_mods_port_map.keys()[1]
table_id = testutils.EX_L3_TABLE
flow_count = 10
testutils.delete_all_flows_one_table(self.controller, self.logger, table_id)
match_fields_ls = []
ipv6_src_addr = 'fe80::2420:52ff:fe8f:5188'
metadata_val = 0xaa22334455667788
for i in range(flow_count):
match_fields_ls.append(match_list())
match_fields_ls[i].add(match.eth_type(testutils.IPV6_ETHERTYPE))
match_fields_ls[i].add(match.ipv6_src(ipaddr.IPv6Address(ipv6_src_addr)))
ipv6_dst_addr = 'fe80::2420:52ff:fe8f:' + str(5190+i)
match_fields_ls[i].add(match.ipv6_dst(ipaddr.IPv6Address(ipv6_dst_addr)))
match_fields_ls[i].add(match.metadata(metadata_val))
request = testutils.flow_msg_create(self, None, ing_port=ing_port,
match_fields = match_fields_ls[i], egr_port = egr_port, table_id = table_id)
testutils.flow_msg_install(self, request, False)
match_fields = match_list()
match_fields.add(match.eth_type(testutils.IPV6_ETHERTYPE))
match_fields.add(match.ipv6_src(ipaddr.IPv6Address(ipv6_src_addr)))
response = testutils.flow_stats_get(self, table_id = table_id)
self.assertTrue(len(response.stats) == flow_count,
'Did not add all flows successfully! Get table entry num is %d' %len(response.stats))
request = testutils.flow_msg_create(self, None, None, ing_port, match_fields, table_id = table_id)
request.command = ofp.OFPFC_DELETE
testutils.flow_msg_install(self, request, False)
response = testutils.flow_stats_get(self, table_id = table_id)
self.assertTrue(len(response.stats) == 0,
'Switch did not del the flow entry! Current table entry num is %d' %len(response.stats))
def runTest(self):
global pa_port_map
of_ports = pa_port_map.keys()
of_ports.sort()
self.assertTrue(len(of_ports) > 1, "Not enough ports for test")
ingress_port = of_ports[0]
egress_port = of_ports[1]
rc = testutils.delete_all_flows(self.controller, pa_logger)
self.assertEqual(rc, 0, "Failed to delete all flows")
#controller send flow_mod to switch
pkt = testutils.simple_tcp_packet()
flow_mod_add = testutils.flow_msg_create(
self,
pkt,
ing_port=ingress_port,
egr_port=egress_port,
table_id=testutils.EX_ACL_TABLE)
testutils.flow_msg_install(self, flow_mod_add)
#user send pkt to switch, switch transfer to eng_port
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(egress_port, 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')
#check the stats msg
stat_req = message.flow_stats_request()
stat_req.match_fields = flow_mod_add.match_fields
stat_req.table_id = 0xff
stat_req.out_port = ofp.OFPP_ANY
stat_req.out_group = ofp.OFPG_ANY
pa_logger.info("Sending stats request")
testutils.ofmsg_send(self, stat_req)
(response, _) = self.controller.poll(ofp.OFPT_MULTIPART_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):
ing_port = flow_mods_port_map.keys()[0]
out_port1 = flow_mods_port_map.keys()[1]
out_port2 = flow_mods_port_map.keys()[2]
pkt = testutils.simple_tcp_packet()
testutils.delete_all_flows(self.controller, self.logger)
fm_orig = testutils.flow_msg_create(self,
pkt,
ing_port=ing_port,
egr_port=out_port1)
fm_new = testutils.flow_msg_create(self,
pkt,
ing_port=ing_port,
egr_port=out_port2)
fm_new.command = ofp.OFPFC_MODIFY_STRICT
testutils.ofmsg_send(self, fm_orig)
testutils.ofmsg_send(self, fm_new)
flow_stats = testutils.flow_stats_get(self)
self.assertEqual(len(flow_stats.stats), 1,
"Expected only one flow_mod")
stat = flow_stats.stats[0]
#self.assertEqual(stat.match_fields, fm_new.match_fields)
self.assertEqual(stat.instructions, fm_new.instructions,
"instructions not equal !")
def runExpireTest(self, idle_timeout=0, hard_timeout=0):
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 = delete_all_flows(self.controller, pa_logger)
self.assertEqual(rc, 0, "Failed to delete all flows")
pkt = simple_tcp_packet()
ingress_port = pa_config["base_of_port"]
egress_port = (pa_config["base_of_port"] + 1) % len(of_ports)
pa_logger.info("Ingress " + str(ingress_port) + " to egress " +
str(egress_port))
request = testutils.flow_msg_create(self,
pkt,
ing_port=ingress_port,
egr_port=egress_port,
check_expire=True)
request.cookie = random.randint(0, 9007199254740992)
request.buffer_id = 0xffffffff
request.idle_timeout = idle_timeout
request.hard_timeout = hard_timeout
request.flags |= ofp.OFPFF_SEND_FLOW_REM
match_fields = request.match_fields
pa_logger.info("Inserting flow")
testutils.ofmsg_send(self, request)
(response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 8)
self.assertTrue(response is not None,
'Did not receive flow removed message ')
self.assertEqual(request.cookie, response.cookie,
'Cookies do not match')
if idle_timeout == 0:
self.assertEqual(
ofp.OFPRR_HARD_TIMEOUT, response.reason,
'Flow table entry removal reason is not idle_timeout')
elif hard_timeout == 0:
self.assertEqual(
ofp.OFPRR_IDLE_TIMEOUT, response.reason,
'Flow table entry removal reason is not idle_timeout')
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")
ingress_port = of_ports[0];
egress_port = of_ports[1];
rc = testutils.delete_all_flows(self.controller, pa_logger)
self.assertEqual(rc, 0, "Failed to delete all flows")
#controller send flow_mod to switch
pkt = testutils.simple_tcp_packet()
flow_mod_add = testutils.flow_msg_create(self, pkt, ing_port=ingress_port, egr_port=egress_port, table_id=testutils.EX_ACL_TABLE)
testutils.flow_msg_install(self, flow_mod_add)
#user send pkt to switch, switch transfer to eng_port
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(egress_port, 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')
#check the stats msg
stat_req = message.flow_stats_request()
stat_req.match_fields = flow_mod_add.match_fields
stat_req.table_id = 0xff
stat_req.out_port = ofp.OFPP_ANY;
stat_req.out_group = ofp.OFPG_ANY;
pa_logger.info("Sending stats request")
testutils.ofmsg_send(self, stat_req)
(response, _) = self.controller.poll(ofp.OFPT_MULTIPART_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")
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):
# self.clear_switch()
testutils.clear_switch(self,group_port_map,group_logger)
group_add_msg = \
create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 10, buckets = [
create_bucket(0, 0, 0, [
create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 2000),
create_action(action = ofp.OFPAT_OUTPUT, port = 2)
]),
create_bucket(0, 0, 0, [
create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 3000),
create_action(action = ofp.OFPAT_OUTPUT, port = 3)
])
])
self.send_ctrl_exp_noerror(group_add_msg, 'group add')
packet_in = testutils.simple_tcp_packet(tcp_sport=1000)
flow_add_msg = \
testutils.flow_msg_create(self,packet_in,ing_port = 1,action_list = [
create_action(action = ofp.OFPAT_GROUP, group_id = 10)
])
self.send_ctrl_exp_noerror(flow_add_msg, 'flow add')
self.send_data(packet_in, 1)
self.send_data(packet_in, 1)
self.send_data(packet_in, 1)
group_stats_req = \
create_group_stats_req(10)
response = \
self.send_ctrl_exp_reply(group_stats_req,
ofp.OFPT_STATS_REPLY, 'group stat')
exp_len = ofp.OFP_HEADER_BYTES + \
ofp.OFP_STATS_REPLY_BYTES + \
ofp.OFP_GROUP_STATS_BYTES + \
ofp.OFP_BUCKET_COUNTER_BYTES * 2
self.assertEqual(len(response), exp_len,
'Received packet length does not equal expected length')
def runTest(self):
table_id = testutils.EX_L2_TABLE
of_ports = exact_port_map.keys()
egr_port = of_ports[1]
pkt = testutils.simple_tcp_packet(dl_src='08:02:ff:34:88:99', dl_dst='22:22:ed:22:5f:1a')
request = testutils.flow_msg_create(self, pkt, egr_port = egr_port, table_id = table_id)
for obj in request.match_fields.tlvs:
if obj.field == ofp.OFPXMT_OFB_METADATA:
obj.value = 0x9922334455667788
request.idle_timeout = 1
request.flags |= ofp.OFPFF_SEND_FLOW_REM
testutils.flow_msg_install(self, request)
#print(request.show())
(response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 3)
self.assertTrue(response is not None, 'Did not receive flow removed message ')
self.assertEqual(request.cookie, response.cookie, 'Cookies do not match')
self.assertEqual(ofp.OFPRR_IDLE_TIMEOUT, response.reason, 'Flow table entry removal reason is not idle_timeout')
def runExpireTest(self, idle_timeout=0, hard_timeout=0):
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 = delete_all_flows(self.controller, pa_logger)
self.assertEqual(rc, 0, "Failed to delete all flows")
pkt = simple_tcp_packet()
ingress_port = pa_config["base_of_port"]
egress_port = (pa_config["base_of_port"] + 1) % len(of_ports)
pa_logger.info("Ingress " + str(ingress_port) +
" to egress " + str(egress_port))
request = testutils.flow_msg_create(self, pkt, ing_port=ingress_port, egr_port=egress_port, check_expire=True)
request.cookie = random.randint(0,9007199254740992)
request.buffer_id = 0xffffffff
request.idle_timeout = idle_timeout
request.hard_timeout = hard_timeout
request.flags |= ofp.OFPFF_SEND_FLOW_REM
match_fields = request.match_fields
pa_logger.info("Inserting flow")
testutils.ofmsg_send(self, request)
(response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 8)
self.assertTrue(response is not None,
'Did not receive flow removed message ')
self.assertEqual(request.cookie, response.cookie,
'Cookies do not match')
if idle_timeout == 0:
self.assertEqual(ofp.OFPRR_HARD_TIMEOUT, response.reason,
'Flow table entry removal reason is not idle_timeout')
elif hard_timeout == 0:
self.assertEqual(ofp.OFPRR_IDLE_TIMEOUT, response.reason,
'Flow table entry removal reason is not idle_timeout')
def runTest(self):
of_ports = testutils.clear_switch(self, exact_port_map.keys(), exact_logger)#zhaoxiuchu
table_id = testutils.EX_L2_TABLE
of_ports = exact_port_map.keys()
egr_port = of_ports[1]
pkt = testutils.simple_tcp_packet(dl_src='08:02:03:04:88:99', dl_dst='22:22:22:22:22:22')
pkt_metadata = {'metadata_val':0xad22332e6f667588,
'metadata_msk':0xFFFFFFFFFFFFFFFF}
request = testutils.flow_msg_create(self, pkt, pkt_metadata, egr_port = egr_port, table_id = table_id)
request.hard_timeout = 1
request.flags |= ofp.OFPFF_SEND_FLOW_REM
testutils.flow_msg_install(self, request)
#print(request.show())
(response, _) = self.controller.poll(ofp.OFPT_FLOW_REMOVED, 3)
self.assertTrue(response is not None,'Did not receive flow removed message ')
self.assertEqual(request.cookie, response.cookie,'Cookies do not match')
self.assertEqual(ofp.OFPRR_HARD_TIMEOUT, response.reason, 'Flow table entry removal reason is not idle_timeout')
def runTest(self):
"""
** 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
"""
of_ports = testutils.clear_switch(self, pa_port_map.keys(), pa_logger)
# Set up first match
testutils.write_goto(self, testutils.WC_ACL_TABLE,
testutils.WC_SERV_TABLE)
# Set up second match
testutils.write_goto_output(self, testutils.WC_SERV_TABLE,
testutils.EX_L2_TABLE, of_ports[0],
of_ports[2])
# Set up third match, "Empty Instruction"
pkt = testutils.simple_tcp_packet()
request = testutils.flow_msg_create(self,
pkt,
ing_port=of_ports[2],
table_id=testutils.EX_L2_TABLE)
testutils.flow_msg_install(self, request)
# Set up fourth match
testutils.write_output(self, testutils.EX_VLAN_TABLE, of_ports[1])
# Generate a packet matching flow 1, 2, and 3; rcv on port[0]
testutils.reply_check_dp(self,
tcp_sport=1234,
ing_port=of_ports[2],
egr_port=of_ports[0])
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_fields = testutils.packet_to_exact_flow_match(pkt)
self.assertTrue(match_fields 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))
act1.port = egress_port1
act2.port = egress_port2
request = testutils.flow_msg_create(
self,
pkt,
ing_port=ingress_port,
action_list=[act1, act2],
inst_app_flag=testutils.APPLY_ACTIONS_INSTRUCTION)
pa_logger.info("Inserting flow")
testutils.ofmsg_send(self, request)
pa_logger.info("Sending packet to dp port " + str(ingress_port))
self.dataplane.send(ingress_port, str(pkt))
yes_ports = set([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):
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):
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 flow_match_test_port_pair_mpls_two_tables(
parent,
ing_port,
egr_port,
wildcards=0,
mpls_type=ETHERTYPE_MPLS,
mpls_label=-1,
mpls_tc=0,
mpls_ttl=64,
mpls_label_int=-1,
mpls_tc_int=0,
mpls_ttl_int=32,
ip_ttl=192,
label_match_tbl0=0,
tc_match_tbl0=0,
dl_type_match_tbl0=ETHERTYPE_MPLS,
action_list_tbl0=None,
check_expire_tbl0=False,
match_exp_tbl0=True,
exp_msg_tbl0=ofp.OFPT_FLOW_REMOVED,
exp_msg_type_tbl0=0,
exp_msg_code_tbl0=0,
label_match_tbl1=0,
tc_match_tbl1=0,
dl_type_match_tbl1=ETHERTYPE_MPLS,
check_expire_tbl1=False,
match_exp_tbl1=True,
exp_msg_tbl1=ofp.OFPT_FLOW_REMOVED,
exp_msg_type_tbl1=0,
exp_msg_code_tbl1=0,
add_tag_exp=False,
exp_mpls_type=ETHERTYPE_MPLS,
exp_mpls_label=-1,
exp_mpls_tc=0,
exp_mpls_ttl=64,
exp_mpls_ttl_int=32,
exp_ip_ttl=192,
pkt=None,
exp_pkt=None):
"""
Flow match test for various mpls matching patterns on single TCP packet
Run test with packet through switch from ing_port to egr_port
See flow_match_test for parameter descriptions
"""
parent.logger.info("Pkt match test: " + str(ing_port) + " to " +
str(egr_port))
parent.logger.debug(" WC: " + hex(wildcards) + " mpls label: " +
str(mpls_label) + " mpls tc: " + str(mpls_tc) +
" expire_table0: " + str(check_expire_tbl0) +
" expire_table1: " + str(check_expire_tbl1))
# Check if the switch supports all the MPLS actions
sup_act_dic = mplsact.mpls_action_support_check(parent)
sup_act_elm = sup_act_dic.keys()
for i in sup_act_elm:
if sup_act_dic[i] == False:
testutils.skip_message_emit(
parent, "Switch doesn't support " +
"one or more of MPLS actions : " + i)
return
len = 100
len_w_shim = len + 4
len_w_2shim = len_w_shim + 4
len_w_3shim = len_w_2shim + 4
if pkt is None:
if mpls_label >= 0:
if mpls_label_int >= 0:
pktlen = len_w_2shim
else:
pktlen = len_w_shim
else:
pktlen = len
pkt = testutils.simple_tcp_packet_w_mpls(pktlen=pktlen,
mpls_type=mpls_type,
mpls_label=mpls_label,
mpls_tc=mpls_tc,
mpls_ttl=mpls_ttl,
mpls_label_int=mpls_label_int,
mpls_tc_int=mpls_tc_int,
mpls_ttl_int=mpls_ttl_int,
ip_ttl=ip_ttl)
if exp_pkt is None:
if exp_mpls_label >= 0:
if add_tag_exp:
if mpls_label_int >= 0:
exp_pktlen = len_w_3shim
else:
exp_pktlen = len_w_2shim
else:
if mpls_label_int >= 0:
exp_pktlen = len_w_2shim
else:
exp_pktlen = len_w_shim
else:
#subtract action
if mpls_label_int >= 0:
exp_pktlen = len_w_shim
else:
exp_pktlen = len
if add_tag_exp:
exp_pkt = testutils.simple_tcp_packet_w_mpls(
pktlen=exp_pktlen,
mpls_type=exp_mpls_type,
mpls_label_ext=exp_mpls_label,
mpls_tc_ext=exp_mpls_tc,
mpls_ttl_ext=exp_mpls_ttl,
mpls_label=mpls_label,
mpls_tc=mpls_tc,
mpls_ttl=mpls_ttl,
mpls_label_int=mpls_label_int,
mpls_tc_int=mpls_tc_int,
mpls_ttl_int=exp_mpls_ttl_int,
ip_ttl=exp_ip_ttl)
else:
if (exp_mpls_label < 0) and (mpls_label_int >= 0):
exp_pkt = testutils.simple_tcp_packet_w_mpls(
pktlen=exp_pktlen,
mpls_type=mpls_type,
mpls_label=mpls_label_int,
mpls_tc=mpls_tc_int,
mpls_ttl=exp_mpls_ttl_int,
ip_ttl=exp_ip_ttl)
else:
exp_pkt = testutils.simple_tcp_packet_w_mpls(
pktlen=exp_pktlen,
mpls_type=exp_mpls_type,
mpls_label=exp_mpls_label,
mpls_tc=exp_mpls_tc,
mpls_ttl=exp_mpls_ttl,
mpls_label_int=mpls_label_int,
mpls_tc_int=mpls_tc_int,
mpls_ttl_int=exp_mpls_ttl_int,
ip_ttl=exp_ip_ttl)
# Flow Mod for Table0
match = parse.packet_to_flow_match(pkt)
parent.assertTrue(match is not None, "Flow match from pkt failed")
match.mpls_label = label_match_tbl0
match.mpls_tc = tc_match_tbl0
match.dl_type = dl_type_match_tbl0
if ((dl_type_match_tbl0 == ETHERTYPE_MPLS)
or (dl_type_match_tbl0 == ETHERTYPE_MPLS_MC)):
match.nw_tos = 0
match.nw_proto = 0
match.nw_src = 0
match.nw_src_mask = 0
match.nw_dst = 0
match.nw_dst_mask = 0
match.tp_src = 0
match.tp_dst = 0
inst_1 = instruction.instruction_apply_actions()
inst_2 = instruction.instruction_goto_table()
inst_2.table_id = 1
inst_list = [inst_1, inst_2]
request0 = testutils.flow_msg_create(parent,
pkt,
ing_port=ing_port,
instruction_list=inst_list,
action_list=action_list_tbl0,
wildcards=wildcards,
match=match,
check_expire=check_expire_tbl0,
table_id=0)
testutils.flow_msg_install(parent, request0)
# Flow Mod for Table1
match = parse.packet_to_flow_match(exp_pkt)
parent.assertTrue(match is not None, "Flow match from pkt failed")
match.mpls_label = label_match_tbl1
match.mpls_tc = tc_match_tbl1
match.dl_type = dl_type_match_tbl1
if ((dl_type_match_tbl1 == ETHERTYPE_MPLS)
or (dl_type_match_tbl1 == ETHERTYPE_MPLS_MC)):
match.nw_tos = 0
match.nw_proto = 0
match.nw_src = 0
match.nw_src_mask = 0
match.nw_dst = 0
match.nw_dst_mask = 0
match.tp_src = 0
match.tp_dst = 0
request1 = testutils.flow_msg_create(parent,
pkt,
ing_port=ing_port,
wildcards=wildcards,
match=match,
check_expire=check_expire_tbl1,
table_id=1,
egr_port=egr_port)
testutils.flow_msg_install(parent, request1)
parent.logger.debug("Send packet: " + str(ing_port) + " to " +
str(egr_port))
parent.dataplane.send(ing_port, str(pkt))
# Check response from switch
#@todo Not all HW supports both pkt and byte counters
#@todo We shouldn't expect the order of coming response..
if match_exp_tbl0:
if check_expire_tbl0:
flow_removed_verify(parent,
request0,
pkt_count=1,
byte_count=pktlen)
else:
if exp_msg_tbl0 is ofp.OFPT_FLOW_REMOVED:
if check_expire_tbl0:
flow_removed_verify(parent,
request0,
pkt_count=0,
byte_count=0)
elif exp_msg_tbl0 is ofp.OFPT_ERROR:
error_verify(parent, exp_msg_type_tbl0, exp_msg_code_tbl0)
else:
parent.assertTrue(0,
"Rcv: Unexpected Message: " + str(exp_msg_tbl0))
if match_exp_tbl1:
if check_expire_tbl1:
flow_removed_verify(parent,
request1,
pkt_count=1,
byte_count=exp_pktlen)
else:
if exp_msg_tbl1 is ofp.OFPT_FLOW_REMOVED:
if check_expire_tbl1:
flow_removed_verify(parent,
request1,
pkt_count=0,
byte_count=0)
elif exp_msg_tbl1 is ofp.OFPT_ERROR:
error_verify(parent, exp_msg_type_tbl1, exp_msg_code_tbl1)
else:
parent.assertTrue(0,
"Rcv: Unexpected Message: " + str(exp_msg_tbl1))
# Check pkt
if match_exp_tbl0 and match_exp_tbl1:
testutils.receive_pkt_verify(parent, egr_port, exp_pkt)
else:
(_, rcv_pkt, _) = parent.dataplane.poll(timeout=1)
parent.assertFalse(rcv_pkt is not None, "Packet on dataplane")
def write_action_test_multi_tables(parent, ing_port, egr_port,
match = None,
wildcards = 0,
act_list = None,
next_avail = None,
chk_expire = None,
pkt = None,
exp_pkt = None):
"""
Testing framework for write_action tests with multiple tables
@param parent Must implement controller, dataplane, assertTrue, assertEqual
and logger
@param ing_port Ingress OF port
@param egr_port Egress OF port
@match Match field in flow_mod commans for all the tables
@param wildcard Match.wildcard filed in flow_mod commands for all the tables
@param act_list Array of action list for each table
@param next_avail Array. Indicate False for no more tables are used
@param chk_expire Array. Indicate True if you want flow_removed msg
@param pkt Pkt to be sent
@param exp_pkt Expected pkt
"""
parent.assertTrue(match is not None, "Match param doesn't exist")
parent.assertTrue(act_list is not None, "act_list param doesn't exist")
parent.assertTrue(next_avail is not None, "next_avail param doesn't exist")
parent.assertTrue(chk_expire is not None, "chk_expire param doesn't exist")
wildcards = wildcards & 0xfffffffff # mask out anything out of range
request_list = []
for table_id in range(MAX_TABLE):
inst_list = []
inst = instruction.instruction_write_actions()
inst_list.append(inst)
action_list = act_list[table_id]
check_expire = chk_expire[table_id]
if next_avail[table_id]:
inst = instruction.instruction_goto_table()
inst.table_id = table_id + 1
inst_list.append(inst)
else:
pass
request = testutils.flow_msg_create(parent, pkt, ing_port=ing_port,
instruction_list=inst_list,
action_list=action_list,
wildcards=wildcards,
match=match,
check_expire=check_expire,
table_id=table_id)
request_list.append(request)
testutils.flow_msg_install(parent, request_list[table_id])
if next_avail[table_id]:
pass
else:
num_table_used = table_id + 1
break
parent.logger.debug("Send packet: " + str(ing_port)
+ " to " + str(egr_port))
parent.dataplane.send(ing_port, str(pkt))
# Check response from switch
#@todo Not all HW supports both pkt and byte counters
#@todo We shouldn't expect the order of coming response..
for table_id in range(num_table_used):
if chk_expire[table_id]:
flow_removed_verify(parent, request_list[table_id], pkt_count=1,
byte_count=pktlen)
testutils.receive_pkt_verify(parent, egr_port, exp_pkt)
