def get_openflow_rule(tfs,inv_mapf,rule_id):
ofg = OpenFlow_Rule_Generator(None,cisco_router.HS_FORMAT())
tokens = rule_id.split("_")
tf_name = ""
for i in range(len(tokens)-1):
tf_name += tokens[i] + "_"
tf_name = tf_name[:-1]
if tf_name == "":
tf = tfs["topology"]
rule = tf.id_to_rule[rule_id]
rprint = "LINK: %s-->%s"%(inv_mapf[rule["in_ports"][0]],inv_mapf[rule["out_ports"][0]])
return rprint
else:
tf = tfs[tf_name]
rule = tf.id_to_rule[rule_id]
of_rule = ofg.parse_rule(rule)
(match,rw) = ofg.pretify(of_rule)
return "%s %s"%(match,rw)
def get_openflow_rule(tfs,inv_mapf,rule_id):
ofg = OpenFlow_Rule_Generator(None,cisco_router.HS_FORMAT())
tokens = rule_id.split("_")
tf_name = ""
for i in range(len(tokens)-1):
tf_name += tokens[i] + "_"
tf_name = tf_name[:-1]
if tf_name == "":
tf = tfs["topology"]
rule = tf.id_to_rule[rule_id]
rprint = "LINK: %s-->%s"%(inv_mapf[rule["in_ports"][0]],inv_mapf[rule["out_ports"][0]])
return rprint
else:
tf = tfs[tf_name]
rule = tf.id_to_rule[rule_id]
of_rule = ofg.parse_rule(rule)
(match,rw) = ofg.pretify(of_rule)
return "%s %s"%(match,rw)
format["ip_dst_pos"] = 0
format["ip_dst_len"] = 4
format["length"] = 4
rtr_names = [
"bbra_rtr",
"bbrb_rtr",
"boza_rtr",
"bozb_rtr",
"coza_rtr",
"cozb_rtr",
"goza_rtr",
"gozb_rtr",
"poza_rtr",
"pozb_rtr",
"roza_rtr",
"rozb_rtr",
"soza_rtr",
"sozb_rtr",
"yoza_rtr",
"yozb_rtr",
]
for rtr_name in rtr_names:
f = TF(1)
f.load_object_from_file("../work/tf_simple_stanford_backbone/%s.tf" %
rtr_name)
#OFG = OpenFlow_Rule_Generator(f,ciscoRouter(1).HS_FORMAT())
OFG = OpenFlow_Rule_Generator(f, format)
OFG.generate_of_rules("%s.of" % rtr_name)
format["ip_dst_len"] = 4
format["length"] = 4
rtr_names = ["bbra_rtr",
"bbrb_rtr",
"boza_rtr",
"bozb_rtr",
"coza_rtr",
"cozb_rtr",
"goza_rtr",
"gozb_rtr",
"poza_rtr",
"pozb_rtr",
"roza_rtr",
"rozb_rtr",
"soza_rtr",
"sozb_rtr",
"yoza_rtr",
"yozb_rtr",
]
if (not os.path.isdir("stanford_openflow_rules")):
os.makedirs("stanford_openflow_rules")
for rtr_name in rtr_names:
f = TF(1)
f.load_object_from_file("tf_simple_stanford_backbone/%s.tf"%rtr_name)
#OFG = OpenFlow_Rule_Generator(f,ciscoRouter(1).HS_FORMAT())
OFG = OpenFlow_Rule_Generator(f,format)
OFG.generate_of_rules("stanford_openflow_rules/%s.of"%rtr_name)
def __init__(self, definition, ntf, ttf, port_ids, router, no_ft=False):
super(TfTopology, self).__init__()
self.definition = definition
if no_ft:
for rtr1, intf1, rtr2, intf2 in self.definition:
if rtr1 not in self.edges:
self.edges[rtr1] = []
if rtr2 not in self.edges:
self.edges[rtr2] = []
self.edges[rtr1].append(rtr2)
self.edges[rtr2].append(rtr1)
self.switches[rtr1] = Switch(name=rtr1)
self.switches[rtr2] = Switch(name=rtr2)
return
self.ntf = ntf()
self.ttf = ttf()
self.port_map, self.port_reverse_map = port_ids()
self.router = router(1)
self.edge_ports = set()
self.intfs = {}
edge_port_ips = {}
start_ip = ip2int("10.0.0.1")
# keys (ports) should be ints
self.port_reverse_map = dict(
(int(k), v) for (k, v) in self.port_reverse_map.iteritems())
for rtr1, intf1, rtr2, intf2 in self.definition:
if rtr1 not in self.intfs:
self.intfs[rtr1] = {}
if rtr2 not in self.intfs:
self.intfs[rtr2] = {}
if rtr1 not in self.edges:
self.edges[rtr1] = []
if rtr2 not in self.edges:
self.edges[rtr2] = []
self.intfs[rtr1][intf1] = rtr2
self.intfs[rtr2][intf2] = rtr1
self.edges[rtr1].append(rtr2)
self.edges[rtr2].append(rtr1)
self.switches[rtr1] = Switch(name=rtr1)
self.switches[rtr2] = Switch(name=rtr2)
host_limit = {}
for rtr in self.port_map.keys():
for port in self.port_map[rtr].values():
host_limit[rtr] = int(port) + \
self.router.PORT_TYPE_MULTIPLIER * \
self.router.OUTPUT_PORT_TYPE_CONST
break
# self.edge_ports.add(int(port) +
# self.router.PORT_TYPE_MULTIPLIER *
# self.router.OUTPUT_PORT_TYPE_CONST)
#for port in sorted(self.edge_ports):
for port in sorted(host_limit.values()):
self.edge_ports.add(port)
ip = int2ip(start_ip + len(edge_port_ips))
edge_port_ips[port] = ip
self.hosts[ip] = Host(ip=ip, name=ip)
for tf in self.ntf.tf_list:
ofg = OpenFlow_Rule_Generator(tf, self.router.HS_FORMAT())
rules = ofg.generate_of_rules()
swname = tf.prefix_id
for rule in rules:
#dest = int2ip(rule['ip_dst_match'])
#wc = wc2ip(rule['ip_dst_wc'])
outports = rule['out_ports']
location = tf.prefix_id
nexthops = []
for port in outports:
if port in self.edge_ports:
nexthops.append(edge_port_ips[port])
pass
else:
p = port - self.router.PORT_TYPE_MULTIPLIER
if p in self.port_reverse_map.keys():
portname = self.port_reverse_map[p].split("-")[1]
if portname in self.intfs[location].keys():
nexthop = self.intfs[location][portname]
nexthops.append(nexthop)
else:
# TODO
pass
r = trie.Rule()
r.ruleType = trie.Rule.FORWARDING
r.location = location
r.priority = 1
# TODO: handle multipath
if len(nexthops) > 0:
r.nextHop = nexthops[0]
nw_dst_match = rule['ip_dst_match']
nw_dst_wc = ip2int(wc2ip(rule['ip_dst_wc']))
nw_src_match = rule['ip_src_match']
nw_src_wc = ip2int(wc2ip(rule['ip_src_wc']))
r.fieldValue[HeaderField.Index["NW_DST"]] = nw_dst_match
r.fieldMask[HeaderField.Index["NW_DST"]] = nw_dst_wc
r.fieldValue[HeaderField.Index["NW_SRC"]] = nw_src_match
r.fieldMask[HeaderField.Index["NW_SRC"]] = nw_src_wc
# filter inports - only add edge inports
inports = [
(p + router.PORT_TYPE_MULTIPLIER) for p in rule['in_ports']
if (p + router.PORT_TYPE_MULTIPLIER) in self.edge_ports
]
if len(inports) > 0:
r.fieldValue[HeaderField.Index["IN_PORT"]] = sorted(
inports)[0]
r.fieldMask[HeaderField.Index["IN_PORT"]] = 0xFFFF
# TODO: handle vlan rewrite?
# r.fieldValue[HeaderField.Index["DL_VLAN"]] = rule['vlan_match']
# flow = FlowEntry(dest=dest,
# wildcard=wc,
# location=location,
# nexthops=nexthops)
# add host to edges
for n in nexthops:
if n in self.hosts and n not in self.edges[location]:
self.edges[location].append(n)
if len(nexthops) > 1:
print "Can't handle multiple next hops", nexthops
if len(nexthops) > 0:
# self.switches[swname].ft.append(flow)
self.switches[swname].ft.append(r)
def __init__(self, definition, ntf, ttf, port_ids, router):
super(TfTopology, self).__init__()
self.definition = definition
self.ntf = ntf()
self.ttf = ttf()
self.port_map, self.port_reverse_map = port_ids()
self.router = router(1)
self.edge_ports = set()
self.intfs = {}
for rtr1, intf1, rtr2, intf2 in self.definition:
if rtr1 not in self.intfs:
self.intfs[rtr1] = {}
if rtr2 not in self.intfs:
self.intfs[rtr2] = {}
if rtr1 not in self.edges:
self.edges[rtr1] = []
if rtr2 not in self.edges:
self.edges[rtr2] = []
self.intfs[rtr1][intf1] = rtr2
self.intfs[rtr2][intf2] = rtr1
self.edges[rtr1].append(rtr2)
self.edges[rtr2].append(rtr1)
self.switches[rtr1] = Switch(name=rtr1)
self.switches[rtr2] = Switch(name=rtr2)
for rtr in self.port_map.keys():
for port in self.port_map[rtr].values():
self.edge_ports.add(
int(port) + self.router.PORT_TYPE_MULTIPLIER *
self.router.OUTPUT_PORT_TYPE_CONST)
for tf in self.ntf.tf_list:
ofg = OpenFlow_Rule_Generator(tf, self.router.HS_FORMAT())
rules = ofg.generate_of_rules()
swname = tf.prefix_id
for rule in rules:
dest = int2ip(rule['ip_dst_match'])
wc = wc2ip(rule['ip_dst_wc'])
outports = rule['out_ports']
location = tf.prefix_id
nexthops = []
for port in outports:
if port in self.edge_ports:
# TODO
pass
else:
p = str(port - self.router.PORT_TYPE_MULTIPLIER)
if p in self.port_reverse_map.keys():
portname = self.port_reverse_map[p].split("-")[1]
if portname in self.intfs[location].keys():
nexthop = self.intfs[location][portname]
nexthops.append(nexthop)
else:
# TODO
pass
flow = FlowEntry(dest=dest,
wildcard=wc,
location=location,
nexthops=nexthops)
if len(nexthops) > 0:
self.switches[swname].ft.append(flow)
format = {}
format["ip_dst_pos"] = 0
format["ip_dst_len"] = 4
format["length"] = 4
rtr_names = ["bbra_rtr",
"bbrb_rtr",
"boza_rtr",
"bozb_rtr",
"coza_rtr",
"cozb_rtr",
"goza_rtr",
"gozb_rtr",
"poza_rtr",
"pozb_rtr",
"roza_rtr",
"rozb_rtr",
"soza_rtr",
"sozb_rtr",
"yoza_rtr",
"yozb_rtr",
]
for rtr_name in rtr_names:
f = TF(1)
f.load_object_from_file("../work/tf_simple_stanford_backbone/%s.tf"%rtr_name)
#OFG = OpenFlow_Rule_Generator(f,ciscoRouter(1).HS_FORMAT())
OFG = OpenFlow_Rule_Generator(f,format)
OFG.generate_of_rules("%s.of"%rtr_name)
from utils.wildcard_utils import set_header_field
from utils.wildcard import wildcard_create_bit_repeat
from utils.helper import dotted_subnet_to_int
OUTPORT_CONST = cisco_router.OUTPUT_PORT_TYPE_CONST * cisco_router.PORT_TYPE_MULTIPLIER
INTER_CONST = cisco_router.INTERMEDIATE_PORT_TYPE_CONST * cisco_router.PORT_TYPE_MULTIPLIER
HS_FORMAT = cisco_router.HS_FORMAT()
def get_fwd_port_id(a_port):
return int(
a_port /
cisco_router.SWITCH_ID_MULTIPLIER) * cisco_router.SWITCH_ID_MULTIPLIER
ofg = OpenFlow_Rule_Generator(None, cisco_router.HS_FORMAT())
def get_openflow_rule(rule, inv_mapf):
in_ports = "in_ports:"
for p in rule["in_ports"]:
in_ports = in_ports + inv_mapf[p] + ","
in_ports = in_ports[0:-1]
out_ports = "out_ports:"
if len(rule["out_ports"]) > 0:
for p in rule["out_ports"]:
out_ports = out_ports + inv_mapf[p] + ","
else:
out_ports = out_ports + "None,"
out_ports = out_ports[0:-1]
of_rule = ofg.parse_rule(rule)
