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