def launch(topo, ip, servers):
"""
Launch Hedera Controller
topo is in format toponame,arg1,arg2,...
"""
# 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)
# Instantiate a topo object from the passed-in file.
if not topo:
raise Exception("please specify topo and args on cmd line")
else:
t = buildTopo(topo, topos)
r = getRouting('hashed', t)
servers = servers.replace(",", " ").split()
servers = [IPAddr(x) for x in servers]
ip = IPAddr(ip)
log.info("Load Balancer Ready.")
core.registerNew(HederaController, t, r, IPAddr(ip), servers)
log.info("Hedera running with topo=%s." % topo)
def launch(ip, servers):
servers = servers.replace(",", " ").split()
servers = [IPAddr(x) for x in servers]
ip = IPAddr(ip)
# 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 _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 launch(ip, servers):
servers = servers.replace(",", " ").split()
servers = [IPAddr(x) for x in servers]
ip = IPAddr(ip)
# 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 _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 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 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 launchLB(service_ip, service_servers, sw_dpid):
try:
# service_servers = service_servers.replace(","," ").split()
# servers = [IPAddr(x) for x in service_servers]
ip = IPAddr(service_ip)
_dpid = sw_dpid
objname = "arp_resp_" + _dpid
arp_launch(eat_packets=False, objname=objname, **{str(ip): True})
logging.getLogger("proto.arp_responder").setLevel(logging.WARN)
# log.info("IP Load Balancer Ready for Switch %s", _dpid)
# core.registerNew(iplb, event.connection, IPAddr(ip), servers)
# log.info("Load Balancing on %s", _dpid)
except Exception as ex:
print ex
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 (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(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 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)
