def _install_shortestpath_arp(match):
try:
cross_path=s_ct_lsps[(str(match.nw_src),str(match.nw_dst))]
src = match.nw_src
dst = match.nw_dst
except KeyError:
cross_path=s_ct_lsps[(str(match.nw_dst),str(match.nw_src))]
src = match.nw_dst
dst = match.nw_src
for i in range(0,len(cross_path)-2,3):
msg = of.ofp_flow_mod()
msg.match = of.ofp_match(in_port=match.in_port, dl_type =0x0806, nw_src = src, nw_dst = dst)
msg.idle_timeout = 500
msg.flags = of.OFPFF_SEND_FLOW_REM
msg.actions.append(of.ofp_action_output(port = cross_path[i+1]))
log.debug("CROSS_TRAFFIC: Installing forward from switch %s to output port %s", cross_path[i], cross_path[i+1])
poxcore.openflow.sendToDPID(poxutil.str_to_dpid(cross_path[i]),msg)
rev_msg = of.ofp_flow_mod()
rev_msg.match = of.ofp_match(in_port=cross_path[i+1], dl_type =0x0806, nw_src = dst, nw_dst = src)
rev_msg.idle_timeout = 500
rev_msg.flags = of.OFPFF_SEND_FLOW_REM
rev_msg.actions.append(of.ofp_action_output(port = cross_path[i+2]))
log.debug("CROSS_TRAFFIC: Installing reverse from switch %s to output port %s", cross_path[i], cross_path[i+2])
poxcore.openflow.sendToDPID(poxutil.str_to_dpid(cross_path[i]),rev_msg)
def removeFlowBytes(self, byte_count, sw1, port1, sw2, port2 = None):
l = self.findLink(sw1 = str_to_dpid(sw1), port1 = port1, sw2 = str_to_dpid(sw2))
if l is not None:
log.debug("Found link that i need to decrease prev counter for. From %s to %s", sw1, sw2)
# log.debug("%s | %s Link Counters before removing FlowRemoved stats--> Prev: %i", l.sw1, l.sw2, l.prev_counter)
l.prev_counter = l.prev_counter - byte_count # remove total flow removed byte count from counter
# l.cashed_flrmv_count=f.byte_count # cache value for future use
log.debug("Decreased prev counter by %i bytes. New counter value is %i", byte_count, l.prev_counter)
def _install_flow_bcast(self, mhst):
for v in mhst._adj_matrix:
if is_host(v):
continue
for u in mhst._adj_matrix[v]:
# create flow for bcast packet
match = of.ofp_match()
match.dl_type = pkt.ethernet.IP_TYPE
match.in_port = mhst._adj_matrix[v][u]
#match.dl_src = EthAddr("00:00:00:FF:FF:FF")
match.dl_dst = EthAddr("00:00:00:FF:FF:FF")
msg = of.ofp_flow_mod()
msg.priority = 40000
msg.match = match
#msg.actions.append(of.ofp_action_dl_addr.set_src(EthAddr("00:00:00:FF:FF:FF")))
for w in mhst._adj_matrix[v]:
if w != u:
out_port = mhst._adj_matrix[v][w]
# if output link to host change dst mac addr to that machine
#if is_host(w):
# dl_dst = self._host_list[w].mac_address
# msg.actions.append(of.ofp_action_dl_addr.set_dst(dl_dst))
msg.actions.append(of.ofp_action_output(port = out_port))
self._datapath_list[str_to_dpid(v)].connection.send(msg)
def launch (transparent=False, hold_down=_flood_delay, ignore = None):
url = 'amqp://*****:*****@dinosaur.rmq.cloudamqp.com/cuvzmrst'
params = pika.URLParameters(url)
connection = pika.BlockingConnection(params)
threading._start_new_thread(subs,())
threading._start_new_thread(pub,())
channel = connection.channel()
channel.queue_declare(queue='pub2', durable=True)
print('')
message = "Controller 1 aktif"
channel.basic_publish(exchange='',
routing_key='pub2',
body=message,
properties=pika.BasicProperties(
delivery_mode = 2, # make message persistent
))
print("%r" % message)
"""
Starts an L2 learning switch.
"""
try:
global _flood_delay
_flood_delay = int(str(hold_down), 10)
assert _flood_delay >= 0
except:
raise RuntimeError("Expected hold-down to be a number")
if ignore:
ignore = ignore.replace(',', ' ').split()
ignore = set(str_to_dpid(dpid) for dpid in ignore)
print('')
core.registerNew(l2_learning, str_to_bool(transparent), ignore)
def _install_flow_shortest_path(self, src_host, dst_host): src_host = str(src_host) dst_host = str(dst_host) (path, out_ports, in_ports) = self._host_host_path[src_host][dst_host] for dp, out_port, in_port in zip(path, out_ports, in_ports): #nw_tos|tp_dst|dl_dst|dl_src|in_port|dl_vlan_pcp|nw_proto|dl_vlan|tp_src|dl_type|nw_src(/0)|nw_dst(/0) # create flow for send src to dst in shortest path match = of.ofp_match() match.dl_type = pkt.ethernet.IP_TYPE match.in_port = in_port match.nw_src = IPAddr(src_host) match.nw_dst = IPAddr(dst_host) msg = of.ofp_flow_mod() msg.priority = 30000 msg.match = match msg.actions.append(of.ofp_action_output(port = out_port)) self._datapath_list[str_to_dpid(dp)].connection.send(msg) # special match that check source MAC address """
def launch(ip, servers, ignore_dpid):
servers = servers.replace(",", " ").split()
servers = [IPAddr(x) for x in servers]
ip = IPAddr(ip)
ignore_dpid = str_to_dpid(ignore_dpid)
# Boot up ARP Responder
from proto.arp_responder import launch as arp_launch
arp_launch(eat_packets=False, **{str(ip): True})
import logging
logging.getLogger("proto.arp_responder").setLevel(logging.WARN)
def _handle_ConnectionUp(event):
global _dpid
if _dpid is None:
log.info("IP Load Balancer Ready.")
core.registerNew(iplb, event.connection, IPAddr(ip), servers)
_dpid = event.dpid
if event.dpid != ignore_dpid:
core.getLogger().info("Connection %s" % (event.connection, ))
LearningSwitch(event.connection, False)
if _dpid != event.dpid:
log.warn("Ignoring switch %s", event.connection)
else:
log.info("Load Balancing on %s", event.connection)
# Gross hack
core.iplb.con = event.connection
event.connection.addListeners(core.iplb)
core.openflow.addListenerByName("ConnectionUp", _handle_ConnectionUp)
def Ping(s1,s2): global t1 port1 = 0 port2 = 0 mac1 = 0 mac2 = 0 ip1 = 0 ip2 = 0 for item in Switch_set: if s1 == item: for item1 in Switch_set[item]: if s2 == Switch_set[item][item1][0]: port1 = item1 port2 = Switch_set[item][item1][1] break else: continue # print s1,s2 for dpid in ArpTable: if s1 == dpid: for ip in ArpTable[dpid]: if ArpTable[dpid][ip][0] == port1: ip1 = ip mac1 = ArpTable[dpid][ip][1] break elif s2 == dpid: for ip in ArpTable[dpid]: if ArpTable[dpid][ip][0] == port2: ip2 = ip mac2 = ArpTable[dpid][ip][1] break for i in [ip1,ip2,mac1,mac2]: if not i: return False icmp = pkt.icmp() icmp.type = pkt.ICMP.TYPE_ECHO_REQUEST icmp.payload = "PingPing" * 6 ipp = pkt.ipv4() ipp.protocol = ipv4.ICMP_PROTOCOL ipp.srcip = IPAddr(ip1) ipp.dstip = IPAddr(ip2) ipp.payload = icmp e = pkt.ethernet() e.src = mac1 e.dst = mac2 e.type = ethernet.IP_TYPE e.payload = ipp # print "Send Packets!" # print mac1,mac2,ip1,ip2 for i in range(10): msg = of.ofp_packet_out() msg.actions.append(of.ofp_action_output(port = port2)) msg.data = e.pack() core.openflow.sendToDPID(str_to_dpid(s2), msg) t1[(s1,s2)]+=time.time() # print t1 return True
def launch (mss_dpid = "00-00-00-01-00-00|1", mss_ip = None,
mcs_dpid = "00-00-00-02-00-00|2",
dcs_dpids = ["00-00-00-01-01-00|101", "00-00-00-01-02-00|102",
"00-00-00-01-03-00|103"],
dcs_load=[(1.0/3, [1.0/3, 1.0/3, 1.0/3]),
(1.0/3, [1.0/3, 1.0/3, 1.0/3]),
(1.0/3, [1.0/3, 1.0/3, 1.0/3])]):
if mss_ip is None:
mss_ip = IPAddr("10.254.254.254")
mss_dpid = poxutil.str_to_dpid(mss_dpid)
mcs_dpid = poxutil.str_to_dpid(mcs_dpid)
for i in range(len(dcs_dpids)):
dcs_dpids[i] = poxutil.str_to_dpid(dcs_dpids[i])
core.registerNew(PSIKComponent, mss_dpid, mss_ip, mcs_dpid, dcs_dpids, DecisionType.DEC_STATIC, dcs_load)
def do_launch(cls,
address='127.0.0.1',
port=6633,
max_retry_delay=16,
dpid=None,
extra_args=None,
**kw):
"""
Used for implementing custom switch launching functions
cls is the class of the switch you want to add.
Returns switch instance.
"""
print(" DATAPATH : IN DO LAUNCH")
if extra_args is not None:
import ast
extra_args = ast.literal_eval('{%s}' % (extra_args, ))
kw.update(extra_args)
from pox.core import core
if not core.hasComponent('datapaths'):
core.register("datapaths", {})
_switches = core.datapaths
if dpid is None:
for dpid in range(1, 256):
if dpid not in _switches: break
if dpid in _switches:
raise RuntimeError("Out of DPIDs")
else:
dpid = str_to_dpid(dpid)
switch = cls(dpid=dpid, name="sw" + str(dpid), **kw)
_switches[dpid] = switch
switches[dpid] = switch
port = int(port)
max_retry_delay = int(max_retry_delay)
def up(event):
import pox.lib.ioworker
global loop
loop = pox.lib.ioworker.RecocoIOLoop()
#loop.more_debugging = True
loop.start()
OpenFlowWorker.begin(loop=loop,
addr=address,
port=port,
max_retry_delay=max_retry_delay,
switch=switch)
from pox.core import core
core.addListenerByName("UpEvent", up)
return switch
def launch(transparent=False, ignore=None):
"""
Main entrance of this component.
"""
if ignore:
ignore = ignore.replace(',', ' ').split()
ignore = set(str_to_dpid(dpid) for dpid in ignore)
core.registerNew(DirectLivestreaming, str_to_bool(transparent), ignore)
def launch(ip, servers, dpid=None):
disable_flood = False
global all_ports
if disable_flood:
all_ports = of.OFPP_ALL
#core.openflow.addListenerByName("PacketIn", _handle_PacketIn)
log.info("Pair-Learning switch running.")
global _dpid
if dpid is not None:
_dpid = str_to_dpid(dpid)
servers = servers.replace(",", " ").split()
servers = [IPAddr(x) for x in servers]
ip = IPAddr(ip)
# We only want to enable ARP Responder *only* on the load balancer switch,
# so we do some disgusting hackery and then boot it up.
from proto.arp_responder import ARPResponder
old_pi = ARPResponder._handle_PacketIn
def new_pi(self, event):
if event.dpid == _dpid:
# Yes, the packet-in is on the right switch
return old_pi(self, event)
ARPResponder._handle_PacketIn = new_pi
# Hackery done. Now start it.
from proto.arp_responder import launch as arp_launch
arp_launch(eat_packets=False, **{str(ip): True})
import logging
logging.getLogger("proto.arp_responder").setLevel(logging.WARN)
def _handle_ConnectionUp(event):
global _dpid
if _dpid is None:
_dpid = event.dpid
if _dpid != event.dpid:
log.warn("Ignoring switch %s", event.connection)
else:
if not core.hasComponent('iplb'):
# Need to initialize first...
core.registerNew(iplb, event.connection, IPAddr(ip), servers)
log.info("IP Load Balancer Ready.")
log.info("Load Balancing on %s", event.connection)
# Gross hack
core.iplb.con = event.connection
event.connection.addListeners(core.iplb)
core.openflow.addListenerByName("ConnectionUp", _handle_ConnectionUp)
def _send_arp_buffer(self,dpid,dst_ip,mac,outport):
if (dpid,dst_ip) in self.arp_buffers:
log.debug("[%s] Send buffered arp packets to %s",dpid,dst_ip)
buffers = self.arp_buffers[(dpid,dst_ip)]
del self.arp_buffers[(dpid,dst_ip)]
for entry in buffers:
msg = of.ofp_packet_out(buffer_id=entry[1],in_port=entry[2])
msg.actions.append(of.ofp_action_dl_addr.set_dst(mac))
msg.actions.append(of.ofp_action_output(port=outport))
core.openflow.sendToDPID(str_to_dpid(dpid),msg)
def launch (ignore = None):
#Inicializa o controlador
if ignore:
ignore = ignore.replace(',', ' ').split()
ignore = set(str_to_dpid(dpid) for dpid in ignore)
#Cria arquivo de estatisticas
f = open("info_sw.txt", "a+")
f.write ("Tempo Switch RegrasInstaladas RegrasAceitas VezesBloqueado BytesEnviados\n")
f.close()
core.registerNew(l2_learning, ignore)
def get_sw(arg, fail=True):
r = _switches.get(arg)
if r is not None: return r
try:
dpid = str_to_dpid(arg)
except Exception:
raise RuntimeError("No such switch as %s" % (arg, ))
r = core.datapaths.get(dpid)
if r is None and fail:
raise RuntimeError("No such switch as %s" % (dpid_to_str(dpid), ))
return r
def _get_config():
log.debug('Config Module is loaded!')
self.arp_table = ARPTableSet()
for dpid in core.SRPConfig.tor_list:
self.arp_table[dpid] = ARPTable()
ip = IPAddr(parse_cidr(core.SRPConfig.get_tor_lan_addr(dpid))[0])
self.arp_table[dpid][ip] = Entry(_dpid_to_mac(str_to_dpid(dpid)), static=True)
for k, v in kwargs.iteritems():
self.arp_table[dpid][IPAddr(k)] = Entry(v, static=True)
core.Interactive.variables['arp'] = self.arp_table
def updateLinkCounters(self, sw, port, byte_count): # called by monitoring module to update link info after polling
l = self.findLinkByReceiver(sw2 = str_to_dpid(sw), port2 = port)
if l is not None:
log.debug("Found link that i need to increment current counter for. From %s, port:%i to %s, port:%i", l.sw1, l.port1, l.sw2, l.port2)
if l.first_poll is True:
l.cur_counter = byte_count
l.prev_counter = byte_count
l.first_poll = False
else:
l.cur_counter = byte_count # calculate accumulated byte count for this polling period
log.debug("Updated current counter by %i bytes. New counter value is %i", byte_count, l.cur_counter)
def launch(transparent=False, hold_down=_flood_delay, ignore=None):
try:
global _flood_delay
_flood_delay = int(str(hold_down), 10)
assert _flood_delay >= 0
except:
raise RuntimeError("Expected hold-down to be a number")
if ignore:
ignore = ignore.replace(',', ' ').split()
ignore = set(str_to_dpid(dpid) for dpid in ignore)
core.registerNew(l2_learning, str_to_bool(transparent), ignore)
def _add_dpid (self, dpid):
if dpid is True:
# Special case -- everything!
self._dpids = True
return
elif self._dpids is True:
self._dpids = set()
try:
dpid = int(dpid)
except:
dpid = str_to_dpid(dpid)
self._dpids.add(dpid)
def _add_dpid(self, dpid):
if dpid is True:
# Special case -- everything!
self._dpids = True
return
elif self._dpids is True:
self._dpids = set()
try:
dpid = int(dpid)
except:
dpid = str_to_dpid(dpid)
self._dpids.add(dpid)
def do_launch(cls, standalone, address='127.0.0.1', port=6633, max_retry_delay=16,
dpid=None, extra_args=None, **kw):
"""
Used for implementing custom switch launching functions
cls is the class of the switch you want to add.
Returns switch instance.
"""
if extra_args is not None:
import ast
extra_args = ast.literal_eval('{%s}' % (extra_args,))
kw.update(extra_args)
from pox.core import core
if not core.hasComponent('datapaths'):
core.register("datapaths", {})
_switches = core.datapaths
if dpid is None:
for dpid in range(1, 256):
if dpid not in _switches: break
if dpid in _switches:
raise RuntimeError("Out of DPIDs")
else:
dpid = str_to_dpid(dpid)
switch = cls(dpid=dpid, name="sw" + str(dpid), **kw)
_switches[dpid] = switch
port = int(port)
max_retry_delay = int(max_retry_delay)
def up(event):
import pox.lib.ioworker
global loop
loop = pox.lib.ioworker.RecocoIOLoop()
# loop.more_debugging = True
loop.start()
OpenFlowWorker.begin(loop=loop, addr=address, port=port,
max_retry_delay=max_retry_delay, switch=switch)
from pox.core import core
if not standalone:
core.addListenerByName("UpEvent", up)
return switch
def launch(dpid, outside_port, subnet='172.16.1.0/24', inside_ip='172.16.1.1'):
import pox.proto.dhcp_client as dc
dc.launch(dpid=dpid, port=outside_port, port_eth=True)
import pox.proto.arp_helper as ah
ah.launch(use_port_mac=True)
dpid = str_to_dpid(dpid)
inside_ip = IPAddr(inside_ip)
pool = SimpleAddressPool(network=subnet, first=100, last=199)
core.registerNew(NATDHCPD,
install_flow=True,
pool=pool,
ip_address=inside_ip,
router_address=inside_ip,
dns_address=inside_ip,
dpid=dpid,
outside_port=outside_port)
def got_lease(event):
outside_ip = event.lease.address
if not event.lease.routers:
log.error(
"Can't start NAT because we didn't get an upstream gateway")
return
gateway_ip = event.lease.routers[0]
if event.lease.dns_servers:
dns_ip = event.lease.dns_servers[0]
else:
dns_ip = None
log.debug('Starting NAT')
n = NAT(inside_ip,
outside_ip,
gateway_ip,
dns_ip,
outside_port,
dpid,
subnet=subnet)
core.register(n)
def init():
log.debug('Waiting for DHCP lease on port %s', outside_port)
core.DHCPClient.addListenerByName('DHCPLeased', got_lease)
core.call_when_ready(init, ['DHCPClient'])
def _handle_ipv4_buffer_expiration(self):
empty = []
for k, v in self.ipv4_buffers.iteritems():
dpid, ip = k
for item in list(v):
expires_at, buffer_id, in_port = item
if expires_at < time.time():
v.remove(item)
#不为packet out消息指定outport action，则默认使DPID丢弃该报文
msg = of.ofp_packet_out(buffer_id=buffer_id, in_port=in_port)
core.openflow.sendToDPID(str_to_dpid(dpid), msg)
if len(v) == 0:
empty.append(k)
for k in empty:
del self.ipv4_buffers[k]
def recv_manager_command(): #thread
s = socket(AF_INET, SOCK_STREAM)
s.bind(('', ManagerPort))
s.listen(5)
while True:
conn, addr = s.accept()
message = conn.recv(1024)
command = message.split('->')
if command[0] == 'server':
core.l2_multi.raiseEvent(RtpFromServer, IPAddr(command[1]),
int(command[2]))
elif command[0] == 'switch':
core.l2_multi.raiseEvent(RtpFromSwitch, str_to_dpid(command[1]),
IPAddr(command[2]), int(command[3]))
elif command[0] == 'init':
threading.Thread(target=send_path_map, args=()).start()
def _handle_RtpFromServer(self, event):
clientMac = clientIP_mac[event.clientIP]
dest = mac_map[clientMac]
serverswitch = switches[str_to_dpid(ServerSwitchDpid)]
p = _get_path(serverswitch, dest[0], ServerPort, dest[1])
match = of.ofp_match()
match.dl_type = pkt.ethernet.IP_TYPE
match.dl_src = EthAddr(ServerMac)
match.dl_dst = clientMac
match.nw_proto = pkt.ipv4.UDP_PROTOCOL
match.nw_src = IPAddr(ServerIP)
match.nw_dst = event.clientIP
_install_rtp_path(p, match, event.dumpPort)
def launch (transparent=False, hold_down=_flood_delay, ignore = None):
"""
Starts an L2 learning switch.
"""
try:
global _flood_delay
_flood_delay = int(str(hold_down), 10)
assert _flood_delay >= 0
except:
raise RuntimeError("Expected hold-down to be a number")
if ignore:
ignore = ignore.replace(',', ' ').split()
ignore = set(str_to_dpid(dpid) for dpid in ignore)
core.registerNew(l2_learning, str_to_bool(transparent), ignore)
def launch (ip, servers, dpid = None):
global _dpid
if dpid is not None:
_dpid = str_to_dpid(dpid)
servers = servers.replace(","," ").split()
servers = [IPAddr(x) for x in servers]
ip = IPAddr(ip)
from proto.arp_responder import ARPResponder
old_pi = ARPResponder._handle_PacketIn
def new_pi (self, event):
if event.dpid == _dpid:
# Yes, the packet-in is on the right switch
return old_pi(self, event)
ARPResponder._handle_PacketIn = new_pi
# Hackery done. Now start it.
from proto.arp_responder import launch as arp_launch
arp_launch(eat_packets=False,**{str(ip):True})
import logging
logging.getLogger("proto.arp_responder").setLevel(logging.WARN)
def _handle_ConnectionUp (event):
global _dpid
if _dpid is None:
_dpid = event.dpid
if _dpid != event.dpid:
log.warn("Ignoring switch %s", event.connection)
LearningSwitch(event.connection, False)
else:
if not core.hasComponent('iplb'):
# Need to initialize first...
core.registerNew(iplb, event.connection, IPAddr(ip), servers)
#log.info("DPID:", _dpid)
log.info("IP Load Balancer Ready.")
log.info("Load Balancing on %s", event.connection)
# Gross hack
core.iplb.con = event.connection
event.connection.addListeners(core.iplb)
core.openflow.addListenerByName("ConnectionUp", _handle_ConnectionUp)
def launch (ip, servers, dpid = None):
global _dpid
if dpid is not None:
_dpid = str_to_dpid(dpid)
servers = servers.replace(","," ").split()
servers = [IPAddr(x) for x in servers]
ip = IPAddr(ip)
# We only want to enable ARP Responder *only* on the load balancer switch,
# so we do some disgusting hackery and then boot it up.
from proto.arp_responder import ARPResponder
old_pi = ARPResponder._handle_PacketIn
def new_pi (self, event):
if event.dpid == _dpid:
# Yes, the packet-in is on the right switch
return old_pi(self, event)
ARPResponder._handle_PacketIn = new_pi
# Hackery done. Now start it.
from proto.arp_responder import launch as arp_launch
arp_launch(eat_packets=False,**{str(ip):True})
import logging
logging.getLogger("proto.arp_responder").setLevel(logging.WARN)
def _handle_ConnectionUp (event):
global _dpid
if _dpid is None:
_dpid = event.dpid
if _dpid != event.dpid:
log.warn("Ignoring switch %s", event.connection)
else:
if not core.hasComponent('iplb'):
# Need to initialize first...
core.registerNew(iplb, event.connection, IPAddr(ip), servers)
log.info("IP Load Balancer Ready.")
log.info("Load Balancing on %s", event.connection)
# Gross hack
core.iplb.con = event.connection
event.connection.addListeners(core.iplb)
core.openflow.addListenerByName("ConnectionUp", _handle_ConnectionUp)
def launch(transparent=False, hold_down=gFloodDelay, ignore=None):
#
# Now let's get started
#
try:
global gFloodDelay
# class int(x)->int or int(x, base=10)
gFloodDelay = int(str(hold_down))
assert gFloodDelay >= 0
except:
raise RuntimeError("Hold-down should be a real number")
if ignore:
ignore = ignore.replace(',', ' ').split()
ignore = set(str_to_dpid(dpid) for dpid in ignore)
core.registerNew(l2_learning, str_to_bool(transparent), ignore)
def __init__(self):
core.openflow_discovery.addListeners(self)
core.openflow.addListeners(self)
self.brid = {}
self.connections = defaultdict(lambda:None)
for i in range(1,5):
self.brid['br{}'.format(i)] = str_to_dpid("fe-fe-00-0a-ff-0{}".format(i))
# Dict of dicts. [sw1][sw2] return port of sw1 connected to sw2
# Also used for port location of adjacent mac addrs:
# [sw][mac] -> port of switch connected to mac
# self.switch_adjacency = defaultdict(lambda:defaultdict(lambda:None))
# self.table = dict()
self.switches = dict()
def launch (dpid, outside_port, subnet = '172.16.1.0/24',
inside_ip = '172.16.1.1'):
import pox.proto.dhcp_client as dc
dc.launch(dpid = dpid, port = outside_port, port_eth = True)
import pox.proto.arp_helper as ah
ah.launch(use_port_mac = True)
dpid = str_to_dpid(dpid)
inside_ip = IPAddr(inside_ip)
pool = SimpleAddressPool(network = subnet, first = 100, last = 199)
core.registerNew(NATDHCPD, install_flow = True, pool = pool,
ip_address = inside_ip, router_address = inside_ip,
dns_address = inside_ip, dpid = dpid,
outside_port = outside_port)
def got_lease (event):
outside_ip = event.lease.address
if not event.lease.routers:
log.error("Can't start NAT because we didn't get an upstream gateway")
return
gateway_ip = event.lease.routers[0]
if event.lease.dns_servers:
dns_ip = event.lease.dns_servers[0]
else:
dns_ip = None
log.debug('Starting NAT')
n = NAT(inside_ip, outside_ip, gateway_ip, dns_ip, outside_port, dpid,
subnet=subnet)
core.register(n)
def init ():
log.debug('Waiting for DHCP lease on port %s', outside_port)
core.DHCPClient.addListenerByName('DHCPLeased', got_lease)
core.call_when_ready(init, ['DHCPClient'])
def launch(ip, servers, lb_dpid, weights=None):
global _dpid, LBinitDone
try:
servers = servers.replace(",", " ").split()
servers = [IPAddr(x) for x in servers]
if weights is not None:
weights = weights.replace(",", " ").split()
weights = [int(x) for x in weights]
ip = IPAddr(ip)
_dpid = str_to_dpid(lb_dpid)
# Boot up ARP Responder
from proto.arp_responder import launch as arp_launch
arp_launch(eat_packets=False, **{str(ip): True})
import logging
logging.getLogger("proto.arp_responder").setLevel(logging.WARN)
def _handle_ConnectionUp(event):
global _dpid, LBinitDone
# if event.dpid is not same as provided LB's dpid, start learning switch
if _dpid != event.dpid:
log.warn("NOT LB switch %s. Will run learning mode",
event.connection)
LearningSwitch(event.connection, False)
else:
# this is LB's switch. init if not done already
if (LBinitDone != 1):
log.info("IP Load Balancer Ready.")
core.registerNew(iplb, event.connection, IPAddr(ip),
servers, weights)
LBinitDone = 1
log.info("Load Balancing on %s", event.connection)
# Gross hack
core.iplb.con = event.connection
event.connection.addListeners(core.iplb)
except Exception as ex:
print ex
core.openflow.addListenerByName("ConnectionUp", _handle_ConnectionUp)
def launch(transparent=False,
hold_down=_flood_delay,
ignore=None,
droplist_client=[],
droplist_server=[]):
"""
Starts an L2 droplist switch.
"""
try:
global _flood_delay
_flood_delay = int(str(hold_down), 10)
assert _flood_delay >= 0
except:
raise RuntimeError("Expected hold-down to be a number")
if ignore:
ignore = ignore.replace(',', ' ').split()
ignore = set(str_to_dpid(dpid) for dpid in ignore)
core.registerNew(l2_dropper, str_to_bool(transparent), ignore,
droplist_client, droplist_server)
def subscribe(stream):
"""
Runs as a separate thread, and listen to connection up/down messages published on kafka.
:param stream: ip address and port of kafka or zookeeper host e.g 192.168.56.1:9092
"""
consumer = KafkaConsumer('of_connections', bootstrap_servers=stream)
for msg in consumer:
msg = msg.value
action, dpid = msg.split('#')
if action == 'add':
dpid = str_to_dpid(dpid)
if dpid not in core.openflow.connections:
# new connection
con = hctrl.__conn(dpid)
core.openflow._connect(con)
log.info("subscriber: new connection from {}".format(
dpid_to_str(con.dpid)))
else:
# delete connection
core.openflow._disconnect(dpid)
log.info("subscriber: connection down from {}".format(dpid))
log.info("subscriber: shutting down...")
def launch (dpid, port, port_eth = None, name = None, __INSTANCE__ = None):
"""
Launch
port_eth unspecified: "DPID MAC"
port_eth enabled: Port MAC
port_eth specified: Use that
"""
if port_eth in (True, None):
pass
else:
port_eth = EthAddr(port_eth)
dpid = str_to_dpid(dpid)
try:
port = int(port)
except:
pass
def dhcpclient_init ():
n = name
if n is None:
s = ''
while True:
if not core.hasComponent("DHCPClient" + s):
n = "DHCPClient" + s
break
s = str(int('0' + s) + 1)
else:
if core.hasComponent(n):
self.log.error("Already have component %s", n)
return
client = DHCPClient(port=port, dpid=dpid, name=n, port_eth=port_eth)
core.register(n, client)
core.call_when_ready(dhcpclient_init, ['openflow'])
def launch(dpid, port, port_eth=None, name=None, __INSTANCE__=None):
"""
Launch
port_eth unspecified: "DPID MAC"
port_eth enabled: Port MAC
port_eth specified: Use that
"""
if port_eth in (True, None):
pass
else:
port_eth = EthAddr(port_eth)
dpid = str_to_dpid(dpid)
try:
port = int(port)
except:
pass
def dhcpclient_init():
n = name
if n is None:
s = ''
while True:
if not core.hasComponent("DHCPClient" + s):
n = "DHCPClient" + s
break
s = str(int('0' + s) + 1)
else:
if core.hasComponent(n):
self.log.error("Already have component %s", n)
return
client = DHCPClient(port=port, dpid=dpid, name=n, port_eth=port_eth)
core.register(n, client)
core.call_when_ready(dhcpclient_init, ['openflow'])
def launch (ip, servers, dpid = None):
global _dpid
if dpid is not None:
_dpid = str_to_dpid(dpid)
servers = servers.replace(","," ").split()
servers = [IPAddr(x) for x in servers]
ip = IPAddr(ip)
# We only want to enable ARP Responder *only* on the load balancer switch,
# so we do some disgusting hackery and then boot it up.
from proto.arp_responder import ARPResponder
old_pi = ARPResponder._handle_PacketIn
def new_pi (self, event):
if event.dpid == _dpid:
# Yes, the packet-in is on the right switch
return old_pi(self, event)
ARPResponder._handle_PacketIn = new_pi
# Hackery done. Now start it.
from proto.arp_responder import launch as arp_launch
arp_launch(eat_packets=False,**{str(ip):True})
import logging
logging.getLogger("proto.arp_responder").setLevel(logging.WARN)
def _handle_ConnectionUp (event):
global _dpid
if _dpid is None:
_dpid = event.dpid
if _dpid != event.dpid:
log.warn("Ignoring switch %s", event.connection)
else:
def launch (topo):
"""
Launch the Megaswitch component
This is called to intialize this component. Commandline arguments to this
component show up as arguments to this function. We take "topo", which
should be the filename of a topology file.
"""
# We're given a topology file. Quite possibly the same exact one as used by
# garnet. Let's load it and then do a little processing of the graph here to
# remove hosts and convert any string-format DPIDs to numeric DPIDs.
g = gutil.get_graph(topo)
bad_nodes = set() # Things that aren't usable switches
g.names = {}
for n,info in g.nodes(data=True):
if info.get('entity_type','').lower() == 'host':
# Skip hosts
bad_nodes.add(n)
continue
if 'dpid' not in info:
# Our switches need DPIDs!
bad_nodes.add(n)
continue
# Fix string DPIDs
dpid = info['dpid']
if isinstance(dpid, str):
info['dpid'] = str_to_dpid(dpid)
g.names[info['dpid']] = n
g.remove_nodes_from(bad_nodes)
# Create the component and "register" it on the POX core object
core.registerNew(Megaswitch, topo_graph=g)
def updateLinkCounters(self, byte_count, sw1, port1, sw2, port2 = None): # called by monitoring module to update link info after polling
l = self.findLink(sw1 = str_to_dpid(sw1), port1 = port1, sw2 = str_to_dpid(sw2))
if l is not None:
log.debug("Found link that i need to increment current counter for. From %s to %s", sw1, sw2)
l.cur_counter = l.cur_counter + byte_count # calculate accumulated byte count for this polling period
log.debug("Incremented current counter by %i bytes. New counter value is %i", byte_count, l.cur_counter)
def _install_path(conn_dpid, match, init_event, src, ofp_in_port):
global ct_called
#log.debug("CROSSTRAFFIC: check port %d", match.tp_dst)
#log.debug("CROSSTRAFFIC_MATCH: check port %s", match)
#if match.nw_dst != "10.10.10.3" and match.nw_src== "10.10.10.2" and match.nw_src == "10.10.10.4" or match.nw_src == "10.10.10.6" or match.nw_src == "10.10.10.11" or match.nw_src == "10.10.10.7":
if match.nw_dst in cross_list and match.nw_src in cross_list:
_install_shortestpath(match)
log.debug("Calling Cross Traffic %s"%match.nw_src)
ct_called = True
return 0
#best_bw=0
log.debug("****************SOURCE %s and DESTINATION %s******************\n"%(match.nw_src,match.nw_dst))
#if str(match.nw_src) in client_list and str(match.nw_src) not in server_list:
# if str(match.nw_dst) not in client_list and str(match.nw_dst) not in server_list:
print "***************Programmed Path*************\n"
for i in client_list:
print i
if ((match.nw_dst in client_port.keys() and match.nw_src in server_list) or (match.nw_dst in server_list and match.nw_src in client_port.keys())) :
if match.nw_dst in server_list:
serv_index = server_list.index(match.nw_dst)
#print server_list[serv_index]
elif match.nw_dst in client_port.keys():
client_index = clientip_list.index((str(match.nw_dst)[0:10]))
client_ip_new = str(match.nw_dst)
#print clientip_list[client_index]
if match.nw_src in server_list:
serv_index = server_list.index(match.nw_src)
#print server_list[serv_index]
elif match.nw_src in client_port.keys():
client_index = clientip_list.index((str(match.nw_src)[0:10]))
client_ip_new = str(match.nw_src)
#print clientip_list[client_index]
log.debug("Client Index is %d and Server Index is %d and CLient IP %s",client_index,serv_index,client_ip_new)
best_path = s_keys[client_index][serv_index]
best_bw = s_lsps[s_keys[client_index][serv_index]][0]
'''
for j in range (len(s_keys[client_index])):
print s_keys[i][j]
for k in range (len(s_lsps[s_keys[i][j]][2])):
print s_lsps[s_keys[i][j]][0]
if best_bw > s_lsps[s_keys[i][j]][0]:
best_path, best_bw = s_keys[i][j], s_lsps[s_keys[i][j]][0]
log.debug("BESTPATH: %s and BESTBW = %d", best_path, best_bw)
'''
packet = init_event.parsed
first_in = init_event.port
#s_lsps[best_path][2][2] = client_port[client_ip_new]
for i in range(0,len(s_lsps[best_path][2])-2,3): #for switch in path.keys():
#log.debug("INSTALLING : VALUE OF i %d and Length %d", i, len(s_lsps[best_path][2]))
cur_sw = s_lsps[best_path][2][i]
#rev_msg = of.ofp_flow_mod()
'''
rev_msg.match = match
rev_msg.match.nw_dst, rev_msg.match.nw_src = rev_msg.match.nw_src , rev_msg.match.nw_dst
rev_msg.match.dl_dst, rev_msg.match.dl_src = rev_msg.match.dl_src, rev_msg.match.dl_dst
rev_msg.match.tp_src, rev_msg.match.tp_dst = rev_msg.match.tp_dst, rev_msg.match.tp_src
'''
'''
if i==0:
rev_port = first_in
src_sw = "client"
dst_sw = s_lsps[best_path][2][i]
msg.match = of.ofp_match(in_port = first_in, dl_type=0x0800, nw_src = match.nw_src, nw_dst = match.nw_dst, tp_src = match.tp_src, tp_dst= match.tp_dst, nw_proto = match.nw_proto)
else:
'''
#msg.in_port = s_lsps[best_path][2][i+2]
src_sw = s_lsps[best_path][2][i]
if i<(len(s_lsps[best_path][2])-3):
dst_sw = s_lsps[best_path][2][i+3]
else:
dst_sw ="last"
if i==0:
cl_port=client_port[client_ip_new]
else:
cl_port=s_lsps[best_path][2][i+2]
if str(match.nw_src) in client_port.keys():
msg = of.ofp_flow_mod()
msg.idle_timeout =10
msg.flags = of.OFPFF_SEND_FLOW_REM
msg.match = of.ofp_match(in_port = cl_port,dl_type =0x0800, nw_src = match.nw_src, nw_dst = match.nw_dst)
log.debug("Installing Forward from switch %s to switch %s: output port %s", src_sw, dst_sw, s_lsps[best_path][2][i+1])
msg.actions.append(of.ofp_action_output(port = s_lsps[best_path][2][i+1]))
#rev_msg.match.in_port = s_lsps[best_path][2][i+1]
#if src_sw != "client":
log.debug("*************CLIENT FLOW: DPID OF CURRENT SWITCH*************%s",cur_sw)
poxcore.openflow.sendToDPID(poxutil.str_to_dpid(cur_sw),msg)
'''
rev_msg = of.ofp_flow_mod()
rev_msg.idle_timeout = 10
rev_msg.flags = of.OFPFF_SEND_FLOW_REM
rev_msg.match = of.ofp_match(in_port = s_lsps[best_path][2][i+1],dl_type =0x0800, nw_src = match.nw_dst, nw_dst = match.nw_src)
rev_msg.out_port = cl_port
log.debug("Installing Reverse from switch %s to switch %s : input port %s and output port %s", src_sw, dst_sw, msg.match.in_port,msg.out_port)
rev_msg.actions.append(of.ofp_action_output(port = cl_port))
poxcore.openflow.sendToDPID(poxutil.str_to_dpid(cur_sw),rev_msg)
'''
elif str(match.nw_dst) in client_port.keys():
msg = of.ofp_flow_mod()
msg.idle_timeout = 10
msg.flags = of.OFPFF_SEND_FLOW_REM
msg.match = of.ofp_match(in_port = s_lsps[best_path][2][i+1],dl_type =0x0800, nw_src = match.nw_src, nw_dst = match.nw_dst)
msg.out_port =cl_port
log.debug("Installing Reverse from switch %s to switch %s : input port %s and output port %s", src_sw, dst_sw, msg.match.in_port, msg.out_port)
msg.actions.append(of.ofp_action_output(port = cl_port))
poxcore.openflow.sendToDPID(poxutil.str_to_dpid(cur_sw),msg)
'''
rev_msg = of.ofp_flow_mod()
rev_msg.idle_timeout = 10
rev_msg.flags = of.OFPFF_SEND_FLOW_REM
rev_msg.match = of.ofp_match(in_port = cl_port,dl_type =0x0800, nw_src = match.nw_dst, nw_dst = match.nw_src)
rev_msg.out_port = s_lsps[best_path][2][i+1]
log.debug("Installing Reverse from switch %s to switch %s : input port %s and output port %s", src_sw, dst_sw, msg.match.in_port,msg.out_port)
rev_msg.actions.append(of.ofp_action_output(port = s_lsps[best_path][2][i+1]))
poxcore.openflow.sendToDPID(poxutil.str_to_dpid(cur_sw),rev_msg)
'''
'''
def CalculatePath(self, temp_match):
# method that calculates the path that must be used to forward traffic for this flow
# search inside the path list and choose primary or backup
for p in self.Paths: # find the path for this flow
if p.flow_match.s_ip == temp_match.s_ip and p.flow_match.d_ip == temp_match.d_ip:
# for every link in the primary path check first if the link exists. Then get the link load
# and keep the highest link load value
prim_cost = 0
for it in p.primary_path:
sw1 = p.primary_path[p.primary_path.index(it)][0] # find switch1 of the link
port1 = p.primary_path[p.primary_path.index(it)][1] # find port1 of the link
try:
sw2 = p.primary_path[p.primary_path.index(it)+1][0] # find switch2 of the link
# use MyTopology method to get cost for that link
# check or change link from dpid to string in MyTopology or use str_to_dpid
tmp = core.current_topology.getLinkCost(sw1 = str_to_dpid(sw1), port1 = port1, sw2 = str_to_dpid(sw2))
if tmp is None:
log.debug("Primary path is broken.")
prim_cost = None
break
if tmp > prim_cost:
prim_cost = tmp
except IndexError:
pass
# log.debug("Node is an egress node for this flow. This is a link to the host - not calculating.")
if (prim_cost is None) or (prim_cost > 50): # MUST change to 50% of capacity value here
# for every link in the secondary path check the link load and keep the highest link load value
sec_cost = 0
for it in p.secondary_path:
sw1 = p.secondary_path[p.secondary_path.index(it)][0] # find switch1 of the link
port1 = p.secondary_path[p.secondary_path.index(it)][1] # find port1 of the link
try:
sw2 = p.secondary_path[p.secondary_path.index(it)+1][0] # find switch2 of the link
tmp = core.current_topology.getLinkCost(sw1 = str_to_dpid(sw1), port1 = port1, sw2 = str_to_dpid(sw2))
if tmp is None:
log.debug("Secondary path is broken.")
sec_cost = None
break
if tmp > sec_cost:
sec_cost = tmp
except IndexError:
pass
#log.debug("Node is an egress node for this flow. This is a link to the host - not calculating.")
# Choose the path that is not broken or the lowest of the values kept
if (prim_cost is not None) and (sec_cost is not None): # if both paths are not broken
if sec_cost < prim_cost: # return the one with the less loaded link on its path
log.debug("Secondary Path less loaded. Forwarding via this one.")
return p.secondary_path
else:
log.debug("Primary Path less loaded. Forwarding via this one.")
return p.primary_path
elif (prim_cost is not None) and (sec_cost is None): # else if secondary path is broken, return primary irrespective of load
log.debug("Secondary Path is broken. Forwarding via Primary.")
return p.primary_path
elif (prim_cost is None) and (sec_cost is not None): # else if primary path is broken, return secondary irrespective of load
log.debug("Primary Path is broken. Forwarding via Secondary.")
return p.secondary_path
elif (prim_cost is None) and (sec_cost is None): # else if both paths are broken, return None
log.debug("Both Paths are broken. Doing nothing and letting packets drop.")
return None
else:
log.debug("Using primary path as it is loaded less than 50%.")
return p.primary_path # if primary link not broken and loaded less than 50%
def launch(ip, servers, strategy=RANDON, dpid=None):
global _dpid, strategy_choosed, server_order, len_server_order
if dpid is not None:
_dpid = str_to_dpid(dpid)
if strategy is not None:
strategy_choosed = strategy
if strategy_choosed != RANDON and strategy_choosed != ROUND_ROBIN and strategy_choosed != ROUND_ROBIN_WEIGHT:
strategy_choosed = RANDON
log.warning(
'The strategy {} is not a validy stratery. Random strategy was put in place.'
.format(strategy))
log.info('Strategy {} used.'.format(strategy_choosed))
if strategy_choosed == ROUND_ROBIN_WEIGHT:
s = servers.replace(",", " ").split()
servers = []
for i, server in enumerate(s):
server = server.split(':')
servers.append(IPAddr(server[0]))
if len(server) == 1:
server_order.append(i)
else:
for k in range(0, int(server[1])):
server_order.append(i)
len_server_order = len(server_order)
log.info('Server ordering {}'.format(server_order))
else:
servers = servers.replace(",", " ").split()
servers = [IPAddr(x) for x in servers]
ip = IPAddr(ip)
# We only want to enable ARP Responder *only* on the load balancer switch,
# so we do some disgusting hackery and then boot it up.
from proto.arp_responder import ARPResponder
old_pi = ARPResponder._handle_PacketIn
def new_pi(self, event):
if event.dpid == _dpid:
# Yes, the packet-in is on the right switch
return old_pi(self, event)
ARPResponder._handle_PacketIn = new_pi
# Hackery done. Now start it.
from proto.arp_responder import launch as arp_launch
arp_launch(eat_packets=False, **{str(ip): True})
import logging
logging.getLogger("proto.arp_responder").setLevel(logging.WARN)
def _handle_ConnectionUp(event):
global _dpid
if _dpid is None:
_dpid = event.dpid
if _dpid != event.dpid:
log.warn("Ignoring switch %s", event.connection)
else:
if not core.hasComponent('iplb'):
# Need to initialize first...
core.registerNew(iplb, event.connection, IPAddr(ip), servers)
log.info("IP Load Balancer Ready.")
log.info("Load Balancing on %s", event.connection)
# Gross hack
core.iplb.con = event.connection
event.connection.addListeners(core.iplb)
core.openflow.addListenerByName("ConnectionUp", _handle_ConnectionUp)
def launch(ip, servers, weights_val=[], dpid=None, algorithm='random'):
global _dpid
global _algorithm
if dpid is not None:
_dpid = str_to_dpid(dpid)
if algorithm not in ALGORITHM_LIST:
log.error("Algorithm %s is not allowed, allowed algorithms: %s",
algorithm, ALGORITHM_LIST.keys())
exit(1)
# Getting the servers IP.
servers = servers.replace(",", " ").split()
servers = [IPAddr(x) for x in servers]
# Parsing the weights for each server.
weights = {}
if len(weights_val) is 0:
weights_val = ""
for x in servers:
weights_val += "1,"
weights_val = weights_val.replace(",", " ").split()
if len(weights_val) is not len(servers):
log.error("Weights array is not the same length than servers array")
exit(1)
for i in range(len(servers)):
weights[servers[i]] = int(weights_val[i])
# Getting the controller IP.
ip = IPAddr(ip)
# We only want to enable ARP Responder *only* on the load balancer switch,
# so we do some disgusting hackery and then boot it up.
from proto.arp_responder import ARPResponder
old_pi = ARPResponder._handle_PacketIn
def new_pi(self, event):
if event.dpid == _dpid:
# Yes, the packet-in is on the right switch
return old_pi(self, event)
ARPResponder._handle_PacketIn = new_pi
# Hackery done. Now start it.
from proto.arp_responder import launch as arp_launch
arp_launch(eat_packets=False, **{str(ip): True})
import logging
logging.getLogger("proto.arp_responder").setLevel(logging.WARN)
def _handle_ConnectionUp(event):
global _dpid
if _dpid is None:
_dpid = event.dpid
if _dpid != event.dpid:
log.warn("Ignoring switch %s", event.connection)
else:
if not core.hasComponent('iplb'):
# Need to initialize first...
core.registerNew(iplb, event.connection, algorithm, IPAddr(ip),
weights, servers)
log.info("IP Load Balancer Ready.")
log.info("Load Balancing on %s", event.connection)
# Gross hack
core.iplb.con = event.connection
event.connection.addListeners(core.iplb)
def _handle_FlowStatsReceived(event):
for f in event.stats:
ip_dst = f.match.nw_dst
ip_src = f.match.nw_src
if ip_dst != None and IPAddr(ip_dst) in core.iplb.servers:
core.iplb.data_transferred[IPAddr(ip_dst)] += f.byte_count
if ip_src != None and IPAddr(ip_src) in core.iplb.servers:
core.iplb.data_transferred[IPAddr(ip_src)] += f.byte_count
core.openflow.addListenerByName("FlowStatsReceived",
_handle_FlowStatsReceived)
core.openflow.addListenerByName("ConnectionUp", _handle_ConnectionUp)
from pox.lib.recoco import Timer
# Send the flow stats to all the switches connected to the controller.
def _timer_func():
for connection in core.openflow._connections.values():
connection.send(
of.ofp_stats_request(body=of.ofp_flow_stats_request()))
# Request flow stats every FLOW_IDLE_TIMEOUT second.
Timer(FLOW_IDLE_TIMEOUT, _timer_func, recurring=True)
def _handle_PacketIn(self, event):
#log.debug("Connection packet in %s at switch %s" % (event.connection, dpid_to_str(event.dpid)))
packet = event.parsed
'''if isinstance(packet.next, ipv4):
log.debug("%i %i IP %s => %s", event.dpid,event.port,
packet.next.srcip,packet.next.dstip)
#log.debug("%i %i IP ", event.dpid, event.port)
elif isinstance(packet.next, arp):
log.debug("%i %i arp ", event.dpid, event.port)
elif isinstance(packet.next, icmp):
log.debug("%i %i icmp ", event.dpid,event.port)
else:
log.debug("%i %i not known protocol ", event.dpid, event.port)'''
#packet is arp
if isinstance(packet.next, arp):
'''log.debug("ARP!!!!!!!!!!!!!!!")
log.debug("destination address is %s" % packet.dst)
log.debug("source address is %s" % packet.src)
log.debug("dest ip address %s" %packet.next.protodst)'''
outport = 0
switch = switch_dpid_name[dpid_to_str(event.dpid)]
if packet.next.protodst == fake_ip_address:
if packet.next.protosrc in client_ip_addresses:
outport = total_client_num + 1
if dpid_to_str(event.dpid) != "00-00-00-00-00-01":
print "wrong switch has arp src is client dst is fake!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
elif packet.next.protosrc in server_ip_addresses:
server_num = server_ip_addresses.index(
packet.next.protosrc) + 1
switches = servers[server_num].get_path()
switch = switch_dpid_name[dpid_to_str(event.dpid)]
if switches.index(switch) == 0:
outport = total_client_num + 1
else:
downlink_switch = switches[switches.index(switch) - 1]
outport = switch_switch_adjacency[downlink_switch][
switch][2]
elif packet.next.protodst in client_ip_addresses:
if packet.next.protosrc in client_ip_addresses or packet.next.protosrc == fake_ip_address:
client_num = client_ip_addresses.index(
packet.next.protodst) + 1
outport = switch_client_port[client_num]
if dpid_to_str(event.dpid) != "00-00-00-00-00-01":
print "wrong switch has arp src is client dst is fake!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
elif packet.next.protosrc in server_ip_addresses:
server_num = server_ip_addresses.index(
packet.next.protosrc) + 1
switches = servers[server_num].get_path()
switch = switch_dpid_name[dpid_to_str(event.dpid)]
if switches.index(switch) == 0:
client_num = client_ip_addresses.index(
packet.next.protodst) + 1
outport = switch_client_port[client_num]
else:
downlink_switch = switches[switches.index(switch) - 1]
outport = switch_switch_adjacency[downlink_switch][
switch][2]
elif packet.next.protodst in server_ip_addresses:
if packet.next.protosrc in client_ip_addresses or packet.next.protosrc == fake_ip_address:
server_num = server_ip_addresses.index(
packet.next.protodst) + 1
switches = servers[server_num].get_path()
switch = switch_dpid_name[dpid_to_str(event.dpid)]
if switches.index(switch) < len(switches) - 1:
downlink_switch = switches[switches.index(switch) + 1]
outport = switch_switch_adjacency[switch][
downlink_switch][1]
else:
outport = switch_server_port[server_num][switch]
'''elif packet.next.protosrc in server_ip_addresses:
log.debug("wrong arp server -> server!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ")
#src server -> sw1
server_num = server_ip_addresses.index(packet.next.protosrc) + 1
switches = servers[server_num].get_path()
switch = switch_dpid_name[dpid_to_str(event.dpid)]
downlink_switch = switches[switches.index(switch) - 1]
outport1 = switch_switch_adjacency[downlink_switch][switch][2]
if switches.index(switch) < len(switches) - 1:
uplink_switch = switches[switches.index(switch) + 1]
inport1 = switch_switch_adjacency[switch][uplink_switch][1]
else:
inport1 = switch_server_port[server_num][switch]
msg = of.ofp_packet_out()
msg.data = event.ofp
msg.match = of.ofp_match.from_packet(packet)
msg.match.in_port = inport1
msg.idle_timeout = 10
#msg.in_port = event.port
msg.actions.append(of.ofp_action_output(port = outport1))
core.openflow.sendToDPID(str_to_dpid(switch_name_dpid[switch]), msg)
log.debug("Installing arp at %s" % switch)
#sw1 -> dst server
server_num = server_ip_addresses.index(packet.next.protodst) + 1
switches = servers[server_num].get_path()
switch = switch_dpid_name[dpid_to_str(event.dpid)]
if switches.index(switch) < len(switches) - 1:
downlink_switch = switches[switches.index(switch) + 1]
outport2 = switch_switch_adjacency[switch][downlink_switch][1]
else:
outport2 = switch_server_port[server_num][switch]
msg = of.ofp_packet_out()
msg.data = event.ofp
msg.match = of.ofp_match.from_packet(packet)
msg.idle_timeout = 10
#msg.in_port = event.port
msg.actions.append(of.ofp_action_output(port = outport))
event.connection.send(msg)'''
msg = of.ofp_packet_out()
msg.data = event.ofp
msg.match = of.ofp_match.from_packet(packet)
msg.idle_timeout = 10
#msg.in_port = event.port
msg.actions.append(of.ofp_action_output(port=outport))
core.openflow.sendToDPID(str_to_dpid(switch_name_dpid[switch]),
msg)
#log.debug("Installing arp at %s" % switch)
#packet is normal ip
elif isinstance(packet.next, ipv4):
#log.debug("IP!!!!!!!!!")
#print("packet.next.dstip is %s, pack.dst is %s" % (packet.next.dstip.toStr(), packet.dst.toStr()))
#establish bi-direction flow tables on switches along the shortest path
#client->server
if packet.next.dstip == fake_ip_address:
server_num = self._calc_server(packet)
print "dst_server_num: " + str(server_num)
global server_count
server_count[server_num] += 1
if load_balancing_path:
servers[server_num].update_path()
switches = servers[server_num].get_path()
switch = switch_dpid_name[dpid_to_str(event.dpid)]
if switches.index(switch) < len(switches) - 1:
downlink_switch = switches[switches.index(switch) + 1]
outport = switch_switch_adjacency[switch][downlink_switch][
1]
else:
outport = switch_server_port[server_num][switch]
new_dl_dst = servers[server_num].macAddr
new_nw_dst = servers[server_num].ipAddr
#print ("client->server")
#rewrite at gateway
#print ("i is %i, outport is %i, dst is %s, src is %s" % (switches.index(switch), outport, new_dl_dst.toStr(), packet.src.toStr()))
msg = of.ofp_flow_mod()
msg.data = event.ofp
msg.match.dl_dst = packet.dst
msg.match.dl_src = packet.src
msg.match.dl_type = packet.type
msg.idle_timeout = 1
msg.actions.append(of.ofp_action_dl_addr.set_dst(new_dl_dst))
msg.actions.append(of.ofp_action_nw_addr.set_dst(new_nw_dst))
msg.actions.append(of.ofp_action_output(port=outport))
core.openflow.sendToDPID(str_to_dpid(switch_name_dpid[switch]),
msg)
#log.debug("Installing at %s" % switch)
elif packet.next.dstip in server_ip_addresses:
server_num = server_ip_addresses.index(packet.next.dstip) + 1
switches = servers[server_num].get_path()
switch = switch_dpid_name[dpid_to_str(event.dpid)]
if switches.index(switch) < len(switches) - 1:
downlink_switch = switches[switches.index(switch) + 1]
outport = switch_switch_adjacency[switch][downlink_switch][
1]
else:
outport = switch_server_port[server_num][switch]
new_dl_dst = servers[server_num].macAddr
new_nw_dst = servers[server_num].ipAddr
#print ("client->server")
#print ("i is %i, outport is %i, dst is %s, src is %s" % (switches.index(switch), outport, new_dl_dst.toStr(), packet.src.toStr()))
msg = of.ofp_flow_mod()
msg.data = event.ofp
msg.match.dl_dst = new_dl_dst
msg.match.dl_src = packet.src
msg.match.dl_type = packet.type
msg.idle_timeout = 1
msg.actions.append(of.ofp_action_output(port=outport))
core.openflow.sendToDPID(str_to_dpid(switch_name_dpid[switch]),
msg)
#log.debug("Installing at %s" % switch)
#server->client
elif packet.next.srcip in server_ip_addresses:
#print ("server->client")
server_num = server_ip_addresses.index(packet.next.srcip) + 1
switches = servers[server_num].get_path()
switch = switch_dpid_name[dpid_to_str(event.dpid)]
if switches.index(switch) == 0:
client_num = self._get_client_num(packet.dst)
outport = switch_client_port[client_num]
else:
downlink_switch = switches[switches.index(switch) - 1]
outport = switch_switch_adjacency[downlink_switch][switch][
2]
#print ("i is %i, outport is %i, dst is %s, src is %s" % (switches.index(switch), outport, packet.dst, packet.src))
msg = of.ofp_flow_mod()
msg.data = event.ofp
msg.match.dl_dst = packet.dst
msg.match.dl_src = packet.src
msg.match.dl_type = packet.type
msg.idle_timeout = 1
#rewrite at gateway
if switches.index(switch) == 0:
new_dl_src = fake_mac_address
new_nw_src = fake_ip_address
msg.actions.append(
of.ofp_action_dl_addr.set_src(new_dl_src))
msg.actions.append(
of.ofp_action_nw_addr.set_src(new_nw_src))
msg.actions.append(of.ofp_action_output(port=outport))
core.openflow.sendToDPID(str_to_dpid(switch_name_dpid[switch]),
msg)
#log.debug("Installing at %s" % switch)
#drop other packets ############## if there are other useful packets this might be wrong
'''else:
def _install_loop_terminate_flow(self, connection):
def install_inout_port(connection, in_port, out_port_list):
for out_port in out_port_list:
match = of.ofp_match()
match.in_port = in_port
msg = of.ofp_flow_mod()
msg.priority = 15000
msg.match = match
msg.actions.append( of.ofp_action_output(port = out_port) )
connection.send(msg)
def install_dst_flow(connection, dst_list, out_port):
for dst in dst_list:
match = of.ofp_match()
match.dl_dst = EthAddr(dst)
msg = of.ofp_flow_mod()
msg.priority = 15000
msg.match = match
msg.actions.append( of.ofp_action_output(port = out_port) )
connection.send(msg)
if connection.dpid == str_to_dpid("96-d0-db-91-0a-44"):
# 1(gre17), 2(gre18), 3(gre19), 4(gre20)
install_dst_flow(connection, ["b6:75:f6:00:77:73","da:01:2e:66:f5:b9","fe:40:67:e8:f2:f3","2e:90:aa:80:59:16"], 1)
install_dst_flow(connection, ["9a:9f:fd:c4:c9:57","32:35:2c:82:ae:3d","0e:54:e6:c0:54:6b","82:33:10:71:04:3c"], 2)
install_dst_flow(connection, ["0e:80:25:28:1c:82","66:e2:51:99:b3:60","f2:0d:f2:5c:ed:7d","72:72:46:ee:26:64"], 3)
install_dst_flow(connection, ["7e:21:05:b9:c1:35","72:5a:9d:3f:05:be","3a:73:5b:bd:5d:56","22:f7:af:9c:7b:b5"], 4)
elif connection.dpid == str_to_dpid("3e-25-98-57-0a-4e"):
# 1(gre21), 2(gre22), 3(gre23), 4(gre24)
install_dst_flow(connection, ["b6:75:f6:00:77:73","da:01:2e:66:f5:b9","fe:40:67:e8:f2:f3","2e:90:aa:80:59:16"], 1)
install_dst_flow(connection, ["9a:9f:fd:c4:c9:57","32:35:2c:82:ae:3d","0e:54:e6:c0:54:6b","82:33:10:71:04:3c"], 2)
install_dst_flow(connection, ["0e:80:25:28:1c:82","66:e2:51:99:b3:60","f2:0d:f2:5c:ed:7d","72:72:46:ee:26:64"], 3)
install_dst_flow(connection, ["7e:21:05:b9:c1:35","72:5a:9d:3f:05:be","3a:73:5b:bd:5d:56","22:f7:af:9c:7b:b5"], 4)
elif connection.dpid == str_to_dpid("4e-5d-91-a4-26-4d"):
# 1(gre1), 2(gre2), 3(gre3), 4(gre4), 5(gre17), 6(gre21)
install_dst_flow(connection, ["b6:75:f6:00:77:73"], 1)
install_dst_flow(connection, ["da:01:2e:66:f5:b9"], 2)
install_dst_flow(connection, ["fe:40:67:e8:f2:f3"], 3)
install_dst_flow(connection, ["2e:90:aa:80:59:16"], 4)
install_dst_flow(connection, ["9a:9f:fd:c4:c9:57","32:35:2c:82:ae:3d","0e:54:e6:c0:54:6b","82:33:10:71:04:3c"], 5)
install_dst_flow(connection, ["0e:80:25:28:1c:82","66:e2:51:99:b3:60","f2:0d:f2:5c:ed:7d","72:72:46:ee:26:64"], 6)
install_dst_flow(connection, ["7e:21:05:b9:c1:35","72:5a:9d:3f:05:be","3a:73:5b:bd:5d:56","22:f7:af:9c:7b:b5"], 6)
elif connection.dpid == str_to_dpid("e2-94-27-d5-ef-4e"):
# 1(gre5), 2(gre6), 3(gre7), 4(gre8), 5(gre18), 6(gre22)
install_dst_flow(connection, ["9a:9f:fd:c4:c9:57"], 1)
install_dst_flow(connection, ["32:35:2c:82:ae:3d"], 2)
install_dst_flow(connection, ["0e:54:e6:c0:54:6b"], 3)
install_dst_flow(connection, ["82:33:10:71:04:3c"], 4)
install_dst_flow(connection, ["b6:75:f6:00:77:73","da:01:2e:66:f5:b9","fe:40:67:e8:f2:f3","2e:90:aa:80:59:16"], 5)
install_dst_flow(connection, ["0e:80:25:28:1c:82","66:e2:51:99:b3:60","f2:0d:f2:5c:ed:7d","72:72:46:ee:26:64"], 6)
install_dst_flow(connection, ["7e:21:05:b9:c1:35","72:5a:9d:3f:05:be","3a:73:5b:bd:5d:56","22:f7:af:9c:7b:b5"], 6)
elif connection.dpid == str_to_dpid("2e-7a-18-38-8c-49"):
# 1(gre9), 2(gre10), 3(gre11), 4(gre12), 5(gre19), 6(gre23)
install_dst_flow(connection, ["0e:80:25:28:1c:82"], 1)
install_dst_flow(connection, ["66:e2:51:99:b3:60"], 2)
install_dst_flow(connection, ["f2:0d:f2:5c:ed:7d"], 3)
install_dst_flow(connection, ["72:72:46:ee:26:64"], 4)
install_dst_flow(connection, ["b6:75:f6:00:77:73","da:01:2e:66:f5:b9","fe:40:67:e8:f2:f3","2e:90:aa:80:59:16"], 5)
install_dst_flow(connection, ["9a:9f:fd:c4:c9:57","32:35:2c:82:ae:3d","0e:54:e6:c0:54:6b","82:33:10:71:04:3c"], 5)
install_dst_flow(connection, ["7e:21:05:b9:c1:35","72:5a:9d:3f:05:be","3a:73:5b:bd:5d:56","22:f7:af:9c:7b:b5"], 6)
elif connection.dpid == str_to_dpid("66-5d-a4-6c-ac-41"):
# 1(gre13), 2(gre14), 3(gre15), 4(gre16), 5(gre20), 6(gre24)
install_dst_flow(connection, ["7e:21:05:b9:c1:35"], 1)
install_dst_flow(connection, ["72:5a:9d:3f:05:be"], 2)
install_dst_flow(connection, ["3a:73:5b:bd:5d:56"], 3)
install_dst_flow(connection, ["22:f7:af:9c:7b:b5"], 4)
install_dst_flow(connection, ["b6:75:f6:00:77:73","da:01:2e:66:f5:b9","fe:40:67:e8:f2:f3","2e:90:aa:80:59:16"], 5)
install_dst_flow(connection, ["9a:9f:fd:c4:c9:57","32:35:2c:82:ae:3d","0e:54:e6:c0:54:6b","82:33:10:71:04:3c"], 5)
install_dst_flow(connection, ["0e:80:25:28:1c:82","66:e2:51:99:b3:60","f2:0d:f2:5c:ed:7d","72:72:46:ee:26:64"], 6)
elif connection.dpid == str_to_dpid("2a-db-19-bc-94-4a"):
# host-01 switch 1(tap0), 2(gre1)
install_inout_port(connection, 1, [2])
install_inout_port(connection, 2, [1])
elif connection.dpid == str_to_dpid("7e-1f-d6-e4-84-4e"):
# host-02 switch 1(tap0), 2(gre2)
install_inout_port(connection, 1, [2])
install_inout_port(connection, 2, [1])
elif connection.dpid == str_to_dpid("ee-14-c4-6a-d3-4f"):
# host-03 switch 1(tap0), 2(gre3)
install_inout_port(connection, 1, [2])
install_inout_port(connection, 2, [1])
elif connection.dpid == str_to_dpid("8e-23-ea-7a-73-48"):
# host-04 switch 1(tap0), 2(gre4)
install_inout_port(connection, 1, [2])
install_inout_port(connection, 2, [1])
elif connection.dpid == str_to_dpid("52-84-05-47-56-4e"):
# host-05 switch 1(tap0), 2(gre5)
install_inout_port(connection, 1, [2])
install_inout_port(connection, 2, [1])
elif connection.dpid == str_to_dpid("8a-68-d2-8b-e6-41"):
# host-06 switch 1(tap0), 2(gre6)
install_inout_port(connection, 1, [2])
install_inout_port(connection, 2, [1])
elif connection.dpid == str_to_dpid("ce-b8-5c-71-5e-4f"):
# host-07 switch 1(tap0), 2(gre7)
install_inout_port(connection, 1, [2])
install_inout_port(connection, 2, [1])
elif connection.dpid == str_to_dpid("4a-84-54-fd-db-43"):
# host-08 switch 1(tap0), 2(gre8)
install_inout_port(connection, 1, [2])
install_inout_port(connection, 2, [1])
elif connection.dpid == str_to_dpid("6a-59-d5-d4-92-44"):
# host-09 switch 1(tap0), 2(gre9)
install_inout_port(connection, 1, [2])
install_inout_port(connection, 2, [1])
elif connection.dpid == str_to_dpid("fe-92-3d-be-8c-47"):
# host-10 switch 1(tap0), 2(gre10)
install_inout_port(connection, 1, [2])
install_inout_port(connection, 2, [1])
elif connection.dpid == str_to_dpid("1a-ab-10-e1-c8-47"):
# host-11 switch 1(tap0), 2(gre11)
install_inout_port(connection, 1, [2])
install_inout_port(connection, 2, [1])
elif connection.dpid == str_to_dpid("fe-98-29-28-fa-4a"):
# host-12 switch 1(tap0), 2(gre12)
install_inout_port(connection, 1, [2])
install_inout_port(connection, 2, [1])
elif connection.dpid == str_to_dpid("9a-29-05-08-c0-47"):
# host-13 switch 1(tap0), 2(gre13)
install_inout_port(connection, 1, [2])
install_inout_port(connection, 2, [1])
elif connection.dpid == str_to_dpid("9a-f2-e1-da-9e-46"):
# host-14 switch 1(tap0), 2(gre14)
install_inout_port(connection, 1, [2])
install_inout_port(connection, 2, [1])
elif connection.dpid == str_to_dpid("8e-6c-82-fe-89-48"):
# host-15 switch 1(tap0), 2(gre15)
install_inout_port(connection, 1, [2])
install_inout_port(connection, 2, [1])
elif connection.dpid == str_to_dpid("6a-35-ac-ba-48-46"):
# host-16 switch 1(tap0), 2(gre16)
install_inout_port(connection, 1, [2])
install_inout_port(connection, 2, [1])
def _handle_PacketIn (self, event):
#log.debug("Connection packet in %s at switch %s" % (event.connection, dpid_to_str(event.dpid)))
packet = event.parsed
'''if isinstance(packet.next, ipv4):
log.debug("%i %i IP %s => %s", event.dpid,event.port,
packet.next.srcip,packet.next.dstip)
#log.debug("%i %i IP ", event.dpid, event.port)
elif isinstance(packet.next, arp):
log.debug("%i %i arp ", event.dpid, event.port)
elif isinstance(packet.next, icmp):
log.debug("%i %i icmp ", event.dpid,event.port)
else:
log.debug("%i %i not known protocol ", event.dpid, event.port)'''
#packet is arp
if isinstance(packet.next, arp):
'''log.debug("ARP!!!!!!!!!!!!!!!")
log.debug("destination address is %s" % packet.dst)
log.debug("source address is %s" % packet.src)
log.debug("dest ip address %s" %packet.next.protodst)'''
outport = 0
switch = switch_dpid_name[dpid_to_str(event.dpid)]
if packet.next.protodst == fake_ip_address:
if packet.next.protosrc in client_ip_addresses:
outport = total_client_num + 1
if dpid_to_str(event.dpid) != "00-00-00-00-00-01":
print "wrong switch has arp src is client dst is fake!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
elif packet.next.protosrc in server_ip_addresses:
server_num = server_ip_addresses.index(packet.next.protosrc) + 1
switches = servers[server_num].get_path()
switch = switch_dpid_name[dpid_to_str(event.dpid)]
if switches.index(switch) == 0:
outport = total_client_num + 1
else:
downlink_switch = switches[switches.index(switch) - 1]
outport = switch_switch_adjacency[downlink_switch][switch][2]
elif packet.next.protodst in client_ip_addresses:
if packet.next.protosrc in client_ip_addresses or packet.next.protosrc == fake_ip_address:
client_num = client_ip_addresses.index(packet.next.protodst) + 1
outport = switch_client_port[client_num]
if dpid_to_str(event.dpid) != "00-00-00-00-00-01":
print "wrong switch has arp src is client dst is fake!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
elif packet.next.protosrc in server_ip_addresses:
server_num = server_ip_addresses.index(packet.next.protosrc) + 1
switches = servers[server_num].get_path()
switch = switch_dpid_name[dpid_to_str(event.dpid)]
if switches.index(switch) == 0:
client_num = client_ip_addresses.index(packet.next.protodst) + 1
outport = switch_client_port[client_num]
else:
downlink_switch = switches[switches.index(switch) - 1]
outport = switch_switch_adjacency[downlink_switch][switch][2]
elif packet.next.protodst in server_ip_addresses:
if packet.next.protosrc in client_ip_addresses or packet.next.protosrc == fake_ip_address:
server_num = server_ip_addresses.index(packet.next.protodst) + 1
switches = servers[server_num].get_path()
switch = switch_dpid_name[dpid_to_str(event.dpid)]
if switches.index(switch) < len(switches) - 1:
downlink_switch = switches[switches.index(switch) + 1]
outport = switch_switch_adjacency[switch][downlink_switch][1]
else:
outport = switch_server_port[server_num][switch]
'''elif packet.next.protosrc in server_ip_addresses:
log.debug("wrong arp server -> server!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ")
#src server -> sw1
server_num = server_ip_addresses.index(packet.next.protosrc) + 1
switches = servers[server_num].get_path()
switch = switch_dpid_name[dpid_to_str(event.dpid)]
downlink_switch = switches[switches.index(switch) - 1]
outport1 = switch_switch_adjacency[downlink_switch][switch][2]
if switches.index(switch) < len(switches) - 1:
uplink_switch = switches[switches.index(switch) + 1]
inport1 = switch_switch_adjacency[switch][uplink_switch][1]
else:
inport1 = switch_server_port[server_num][switch]
msg = of.ofp_packet_out()
msg.data = event.ofp
msg.match = of.ofp_match.from_packet(packet)
msg.match.in_port = inport1
msg.idle_timeout = 10
#msg.in_port = event.port
msg.actions.append(of.ofp_action_output(port = outport1))
core.openflow.sendToDPID(str_to_dpid(switch_name_dpid[switch]), msg)
log.debug("Installing arp at %s" % switch)
#sw1 -> dst server
server_num = server_ip_addresses.index(packet.next.protodst) + 1
switches = servers[server_num].get_path()
switch = switch_dpid_name[dpid_to_str(event.dpid)]
if switches.index(switch) < len(switches) - 1:
downlink_switch = switches[switches.index(switch) + 1]
outport2 = switch_switch_adjacency[switch][downlink_switch][1]
else:
outport2 = switch_server_port[server_num][switch]
msg = of.ofp_packet_out()
msg.data = event.ofp
msg.match = of.ofp_match.from_packet(packet)
msg.idle_timeout = 10
#msg.in_port = event.port
msg.actions.append(of.ofp_action_output(port = outport))
event.connection.send(msg)'''
msg = of.ofp_packet_out()
msg.data = event.ofp
msg.match = of.ofp_match.from_packet(packet)
msg.idle_timeout = 10
#msg.in_port = event.port
msg.actions.append(of.ofp_action_output(port = outport))
core.openflow.sendToDPID(str_to_dpid(switch_name_dpid[switch]), msg)
#log.debug("Installing arp at %s" % switch)
#packet is normal ip
elif isinstance(packet.next, ipv4):
#log.debug("IP!!!!!!!!!")
#print("packet.next.dstip is %s, pack.dst is %s" % (packet.next.dstip.toStr(), packet.dst.toStr()))
#establish bi-direction flow tables on switches along the shortest path
#client->server
if packet.next.dstip == fake_ip_address:
server_num = self._calc_server(packet)
print "dst_server_num: " + str(server_num)
global server_count
server_count[server_num] += 1
if load_balancing_path:
servers[server_num].update_path()
switches = servers[server_num].get_path()
switch = switch_dpid_name[dpid_to_str(event.dpid)]
if switches.index(switch) < len(switches) - 1:
downlink_switch = switches[switches.index(switch) + 1]
outport = switch_switch_adjacency[switch][downlink_switch][1]
else:
outport = switch_server_port[server_num][switch]
new_dl_dst = servers[server_num].macAddr
new_nw_dst = servers[server_num].ipAddr
#print ("client->server")
#rewrite at gateway
#print ("i is %i, outport is %i, dst is %s, src is %s" % (switches.index(switch), outport, new_dl_dst.toStr(), packet.src.toStr()))
msg = of.ofp_flow_mod()
msg.data = event.ofp
msg.match.dl_dst = packet.dst
msg.match.dl_src = packet.src
msg.match.dl_type = packet.type
msg.idle_timeout = 1
msg.actions.append(of.ofp_action_dl_addr.set_dst(new_dl_dst))
msg.actions.append(of.ofp_action_nw_addr.set_dst(new_nw_dst))
msg.actions.append(of.ofp_action_output(port = outport))
core.openflow.sendToDPID(str_to_dpid(switch_name_dpid[switch]), msg)
#log.debug("Installing at %s" % switch)
elif packet.next.dstip in server_ip_addresses:
server_num = server_ip_addresses.index(packet.next.dstip) + 1
switches = servers[server_num].get_path()
switch = switch_dpid_name[dpid_to_str(event.dpid)]
if switches.index(switch) < len(switches) - 1:
downlink_switch = switches[switches.index(switch) + 1]
outport = switch_switch_adjacency[switch][downlink_switch][1]
else:
outport = switch_server_port[server_num][switch]
new_dl_dst = servers[server_num].macAddr
new_nw_dst = servers[server_num].ipAddr
#print ("client->server")
#print ("i is %i, outport is %i, dst is %s, src is %s" % (switches.index(switch), outport, new_dl_dst.toStr(), packet.src.toStr()))
msg = of.ofp_flow_mod()
msg.data = event.ofp
msg.match.dl_dst = new_dl_dst
msg.match.dl_src = packet.src
msg.match.dl_type = packet.type
msg.idle_timeout = 1
msg.actions.append(of.ofp_action_output(port = outport))
core.openflow.sendToDPID(str_to_dpid(switch_name_dpid[switch]), msg)
#log.debug("Installing at %s" % switch)
#server->client
elif packet.next.srcip in server_ip_addresses:
#print ("server->client")
server_num = server_ip_addresses.index(packet.next.srcip) + 1
switches = servers[server_num].get_path()
switch = switch_dpid_name[dpid_to_str(event.dpid)]
if switches.index(switch) == 0:
client_num = self._get_client_num(packet.dst)
outport = switch_client_port[client_num]
else:
downlink_switch = switches[switches.index(switch) - 1]
outport = switch_switch_adjacency[downlink_switch][switch][2]
#print ("i is %i, outport is %i, dst is %s, src is %s" % (switches.index(switch), outport, packet.dst, packet.src))
msg = of.ofp_flow_mod()
msg.data = event.ofp
msg.match.dl_dst = packet.dst
msg.match.dl_src = packet.src
msg.match.dl_type = packet.type
msg.idle_timeout = 1
#rewrite at gateway
if switches.index(switch) == 0:
new_dl_src = fake_mac_address
new_nw_src = fake_ip_address
msg.actions.append(of.ofp_action_dl_addr.set_src(new_dl_src))
msg.actions.append(of.ofp_action_nw_addr.set_src(new_nw_src))
msg.actions.append(of.ofp_action_output(port = outport))
core.openflow.sendToDPID(str_to_dpid(switch_name_dpid[switch]), msg)
#log.debug("Installing at %s" % switch)
#drop other packets ############## if there are other useful packets this might be wrong
'''else:
def launch (ignore = None):
#Inicializa o controlador
if ignore:
ignore = ignore.replace(',', ' ').split()
ignore = set(str_to_dpid(dpid) for dpid in ignore)
core.registerNew(l2_learning, ignore)
