def runTest(self):
testutils.clear_switch(self,config["port_map"],logging)
# 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):
testutils.clear_switch(self,config["port_map"],logging)
# self.clear_switch()
group_add_msg = \
create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_INDIRECT, group_id = 1, buckets = [
create_bucket([
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):
self.clear_switch()
group_add_msg2 = \
create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 2, buckets = [
create_bucket([
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([
create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 3000),
create_action(action = ofp.OFPAT_OUTPUT, port = 3)
]),
create_bucket([
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([
create_action(action = ofp.OFPAT_GROUP, group_id = 2),
]),
create_bucket([
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):
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):
testutils.clear_switch(self,config["port_map"],logging)
# 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):
testutils.clear_switch(self,config["port_map"],logging)
# self.clear_switch()
group_add_msg = \
create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_SELECT, group_id = 1, buckets = [
create_bucket([
create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 2000),
create_action(action = ofp.OFPAT_OUTPUT, port = 2)
], weight = 1),
create_bucket([
create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 3000),
create_action(action = ofp.OFPAT_OUTPUT, port = 3)
], weight = 1),
create_bucket([
create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 4000),
create_action(action = ofp.OFPAT_OUTPUT, port = 4)
], weight = 1)
])
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 = config["port_map"].keys()[0]
out_port1 = config["port_map"].keys()[1]
out_port2 = config["port_map"].keys()[2]
pkt = testutils.simple_tcp_packet()
testutils.delete_all_flows(self.controller, logging)
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.entries),1,
"Expected only one flow_mod")
stat = flow_stats.entries[0]
def canonicalize_match(match):
match.oxm_list.sort(key=lambda x: x.type_len)
canonicalize_match(stat.match)
canonicalize_match(fm_new.match)
self.assertEqual(stat.match, fm_new.match)
self.assertEqual(stat.instructions, fm_new.instructions)
def runTest(self):
# Construct packet to send to dataplane
# Send packet to dataplane, once to each port
# Poll controller with expect message type packet in
rc = testutils.delete_all_flows(self.controller, logging)
self.assertEqual(rc, 0, "Failed to delete all flows")
for of_port in config["port_map"].keys():
logging.info("PKT IN test, port " + str(of_port))
pkt = testutils.simple_tcp_packet()
self.dataplane.send(of_port, str(pkt))
#@todo Check for unexpected messages?
(response, _) = self.controller.poll(ofp.OFPT_PACKET_IN)
self.assertTrue(response is not None,
'Packet in message not received on port ' +
str(of_port))
if str(pkt) != response.data:
logging.debug("pkt len " + str(len(str(pkt))) +
": " + str(pkt))
logging.debug("resp len " +
str(len(str(response.data))) +
": " + str(response.data))
self.assertEqual(str(pkt), response.data,
'Response packet does not match send packet' +
' for port ' + str(of_port))
def runTest(self):
# Construct packet to send to dataplane
# Send packet to dataplane
# Poll controller with expect message type packet in
rc = testutils.delete_all_flows(self.controller, logging)
self.assertEqual(rc, 0, "Failed to delete all flows")
# These will get put into function
outpkt = testutils.simple_tcp_packet()
of_ports = config["port_map"].keys()
of_ports.sort()
for dp_port in of_ports:
msg = ofp.message.packet_out()
msg.in_port = ofp.OFPP_CONTROLLER
msg.buffer_id = 0xffffffff
msg.data = str(outpkt)
act = ofp.action.output()
act.port = dp_port
msg.actions.append(act)
logging.info("PacketOut to: " + str(dp_port))
rv = self.controller.message_send(msg)
self.assertTrue(rv == 0, "Error sending out message")
(of_port, pkt, _) = self.dataplane.poll(timeout=1)
self.assertTrue(pkt is not None, 'Packet not received')
logging.info("PacketOut: got pkt from " + str(of_port))
if of_port is not None:
self.assertEqual(of_port, dp_port, "Unexpected receive port")
self.assertEqual(str(outpkt), str(pkt),
'Response packet does not match send packet')
def runTest(self):
ing_port = config["port_map"].keys()[0]
out_port1 = config["port_map"].keys()[1]
out_port2 = config["port_map"].keys()[2]
pkt = testutils.simple_tcp_packet()
testutils.delete_all_flows(self.controller, logging)
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.entries), 1,
"Expected only one flow_mod")
stat = flow_stats.entries[0]
def canonicalize_match(match):
match.oxm_list.sort(key=lambda x: x.type_len)
canonicalize_match(stat.match)
canonicalize_match(fm_new.match)
self.assertEqual(stat.match, fm_new.match)
self.assertEqual(stat.instructions, fm_new.instructions)
def runTest(self):
# self.clear_switch()
testutils.clear_switch(self,config["port_map"],logging)
group_add_msg = \
create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 10, buckets = [
create_bucket([
create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 2000),
create_action(action = ofp.OFPAT_OUTPUT, port = 2)
]),
create_bucket([
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')
self.assertEqual(len(response.entries), 1, 'Incorrect number of groups')
self.assertEqual(len(response.entries[0].bucket_stats), 2, 'Incorrect number of groups')
self.assertEqual(response.entries[0].packet_count, 3, 'Incorrect group packet count')
self.assertEqual(response.entries[0].byte_count, 300, 'Incorrect group byte count')
for bucket_stat in response.entries[0].bucket_stats:
self.assertEqual(bucket_stat.packet_count, 3, 'Incorrect bucket packet count')
self.assertEqual(bucket_stat.byte_count, 300, 'Incorrect bucket byte count')
def runTest(self):
# self.clear_switch()
testutils.clear_switch(self,config["port_map"],logging)
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):
self.clear_switch()
group_add_msg = \
create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 1, buckets = [
])
self.send_ctrl_exp_noerror(group_add_msg, 'group add')
packet_in = testutils.simple_tcp_packet()
flow_add_msg = \
create_flow_msg(packet = packet_in, in_port = 1, apply_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, None)
def runTest(self):
self.clear_switch()
group_add_msg = \
create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 1, buckets = [
])
self.send_ctrl_exp_noerror(group_add_msg, 'group add')
packet_in = testutils.simple_tcp_packet()
flow_add_msg = \
create_flow_msg(packet = packet_in, in_port = 1, apply_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, None)
def runTest(self):
# self.clear_switch()
testutils.clear_switch(self,config["port_map"],logging)
group_add_msg1 = \
create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 10, buckets = [
create_bucket([
create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 2000),
create_action(action = ofp.OFPAT_OUTPUT, port = 2)
]),
create_bucket([
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_msg1, 'group add 1')
group_add_msg2 = \
create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 20, buckets = [
create_bucket([
create_action(action = ofp.OFPAT_SET_FIELD, tcp_sport = 2000),
create_action(action = ofp.OFPAT_OUTPUT, port = 2)
]),
create_bucket([
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_msg2, 'group add 2')
packet_in = testutils.simple_tcp_packet(tcp_sport=1000)
flow_add_msg1 = \
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_msg1, 'flow add 1')
flow_add_msg2 = \
testutils.flow_msg_create(self,packet_in,ing_port = 2,action_list = [
create_action(action = ofp.OFPAT_GROUP, group_id = 20)
])
self.send_ctrl_exp_noerror(flow_add_msg2, 'flow add 2')
self.send_data(packet_in, 1)
self.send_data(packet_in, 1)
self.send_data(packet_in, 2)
self.send_data(packet_in, 2)
self.send_data(packet_in, 2)
group_stats_req = \
create_group_stats_req(ofp.OFPG_ALL)
response = \
self.send_ctrl_exp_reply(group_stats_req,
ofp.OFPT_STATS_REPLY, 'group stat')
self.assertEqual(len(response.entries), 2)
group10, group20 = sorted(response.entries, key=lambda x: x.group_id)
# Check stats for group 10
self.assertEqual(group10.group_id, 10)
self.assertEqual(group10.ref_count, 1)
self.assertEqual(group10.packet_count, 2)
self.assertEqual(group10.byte_count, 200)
self.assertEqual(len(group10.bucket_stats), 2)
for bucket_stat in group10.bucket_stats:
self.assertEqual(bucket_stat.packet_count, 2)
self.assertEqual(bucket_stat.byte_count, 200)
# Check stats for group 20
self.assertEqual(group20.group_id, 20)
self.assertEqual(group20.ref_count, 1)
self.assertEqual(group20.packet_count, 3)
self.assertEqual(group20.byte_count, 300)
self.assertEqual(len(group20.bucket_stats), 2)
for bucket_stat in group20.bucket_stats:
self.assertEqual(bucket_stat.packet_count, 3)
self.assertEqual(bucket_stat.byte_count, 300)
def runTest(self):
self.clear_switch()
group_add_msg1 = \
create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 1, buckets = [])
self.send_ctrl_exp_noerror(group_add_msg1, 'group add 1')
group_add_msg2 = \
create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 2, buckets = [])
self.send_ctrl_exp_noerror(group_add_msg2, 'group add 2')
packet_in1 = testutils.simple_tcp_packet(tcp_sport=1000)
flow_add_msg1 = \
testutils.flow_msg_create(self,packet_in1,ing_port = 1,action_list = [
create_action(action = ofp.OFPAT_GROUP, group_id = 1),
create_action(action = ofp.OFPAT_OUTPUT, port = 2)
])
self.send_ctrl_exp_noerror(flow_add_msg1, 'flow add 1')
packet_in2 = testutils.simple_tcp_packet(tcp_sport=2000)
flow_add_msg2 = \
testutils.flow_msg_create(self,packet_in2,ing_port = 1,action_list = [
create_action(action = ofp.OFPAT_GROUP, group_id = 2),
create_action(action = ofp.OFPAT_OUTPUT, port = 2)
])
self.send_ctrl_exp_noerror(flow_add_msg2, 'flow add 2')
packet_in3 = testutils.simple_tcp_packet(tcp_sport=3000)
flow_add_msg3 = \
testutils.flow_msg_create(self,packet_in3,ing_port = 1,action_list = [
create_action(action = ofp.OFPAT_GROUP, group_id = 2),
create_action(action = ofp.OFPAT_OUTPUT, port = 2)
])
self.send_ctrl_exp_noerror(flow_add_msg3, 'flow add 3')
packet_in4 = testutils.simple_tcp_packet(tcp_sport=4000)
flow_add_msg4 = \
testutils.flow_msg_create(self,packet_in4,ing_port = 1,action_list = [
create_action(action = ofp.OFPAT_OUTPUT, port = 2)
])
self.send_ctrl_exp_noerror(flow_add_msg4, 'flow add 4')
aggr_stat_req = ofp.message.aggregate_stats_request()
aggr_stat_req.table_id = 0xff
aggr_stat_req.out_port = ofp.OFPP_ANY
aggr_stat_req.out_group = ofp.OFPG_ANY
response = \
self.send_ctrl_exp_reply(aggr_stat_req,
ofp.OFPT_STATS_REPLY, 'group desc stat')
self.assertEqual(response.flow_count, 4,
'Did not match expected flow count')
def runTest(self):
self.clear_switch()
group_add_msg1 = \
create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 1, buckets = [])
self.send_ctrl_exp_noerror(group_add_msg1, 'group add 1')
group_add_msg2 = \
create_group_mod_msg(ofp.OFPGC_ADD, ofp.OFPGT_ALL, group_id = 2, buckets = [])
self.send_ctrl_exp_noerror(group_add_msg2, 'group add 2')
packet_in1 = testutils.simple_tcp_packet(tcp_sport=1000)
flow_add_msg1 = \
testutils.flow_msg_create(self,packet_in1,ing_port = 1,action_list = [
create_action(action = ofp.OFPAT_GROUP, group_id = 1),
create_action(action = ofp.OFPAT_OUTPUT, port = 2)
])
self.send_ctrl_exp_noerror(flow_add_msg1, 'flow add 1')
packet_in2 = testutils.simple_tcp_packet(tcp_sport=2000)
flow_add_msg2 = \
testutils.flow_msg_create(self,packet_in2,ing_port = 1,action_list = [
create_action(action = ofp.OFPAT_GROUP, group_id = 2),
create_action(action = ofp.OFPAT_OUTPUT, port = 2)
])
self.send_ctrl_exp_noerror(flow_add_msg2, 'flow add 2')
packet_in3 = testutils.simple_tcp_packet(tcp_sport=3000)
flow_add_msg3 = \
testutils.flow_msg_create(self,packet_in3,ing_port = 1,action_list = [
create_action(action = ofp.OFPAT_GROUP, group_id = 2),
create_action(action = ofp.OFPAT_OUTPUT, port = 2)
])
self.send_ctrl_exp_noerror(flow_add_msg3, 'flow add 3')
packet_in4 = testutils.simple_tcp_packet(tcp_sport=4000)
flow_add_msg4 = \
testutils.flow_msg_create(self,packet_in4,ing_port = 1,action_list = [
create_action(action = ofp.OFPAT_OUTPUT, port = 2)
])
self.send_ctrl_exp_noerror(flow_add_msg4, 'flow add 4')
aggr_stat_req = ofp.message.aggregate_stats_request()
aggr_stat_req.table_id = 0xff
aggr_stat_req.out_port = ofp.OFPP_ANY
aggr_stat_req.out_group = ofp.OFPG_ANY
response = \
self.send_ctrl_exp_reply(aggr_stat_req,
ofp.OFPT_STATS_REPLY, 'group desc stat')
self.assertEqual(response.stats[0].flow_count, 4,
'Did not match expected flow count')
