def __init__(self):
self.graph = nx.Graph()
self.ht = host_tracker.host_tracker()
core.openflow_discovery.addListeners(self)
self.listenTo(self.ht)
core.addListeners(self)
def start(self):
assert self._thread is None
from pox.core import core
core.addListeners(self, weak=True)
self._thread = Thread(target=self._thread_func)
#self._thread.daemon = True
self._thread.start()
def __init__(self):
core.addListeners(self)
core.openflow_discovery.addListeners(self)
self.nodes = []
self.edges = defaultdict(list)
self.distances = {}
self.ports = {}
def __init__(self, **kw):
"""
Create a switch instance
Additional options over superclass:
log_level (default to default_log_level) is level for this instance
ports is a list of interface names
"""
log_level = kw.pop('log_level', self.default_log_level)
self.magic_virtual_port_names = kw.pop("magic_virtual_port_names",
self.magic_virtual_port_names)
self.q = Queue()
self.t = Thread(target=self._consumer_threadproc)
core.addListeners(self)
ports = kw.pop('ports', [])
kw['ports'] = []
super(PCapSwitch, self).__init__(**kw)
self._next_port = 1
self.px = {}
for p in ports:
self.add_interface(p, start=False)
self.log.setLevel(log_level)
for px in self.px.itervalues():
px.start()
self.t.start()
def __init__ (self):
# This timer handles expiring stuff
self._expire_timer = Timer(5, _handle_expiration, recurring=True)
self._arp_timer = Timer(3, _arp_for_real_servers, recurring=True,
selfStoppable=True)
core.addListeners(self)
def start (self): assert self._thread is None from pox.core import core core.addListeners(self, weak=True) self._thread = Thread(target=self._thread_func) #self._thread.daemon = True self._thread.start()
def __init__ (self, *args, **kw):
"""
Create a switch instance
Additional options over superclass:
log_level (default to default_log_level) is level for this instance
"""
log_level = kw.pop('log_level', self.default_log_level)
self.q = Queue()
self.t = Thread(target=self._consumer_threadproc)
core.addListeners(self)
super(PCapSwitch,self).__init__(*args,**kw)
self.px = {}
for p in self.ports.values():
px = pxpcap.PCap(p.name, callback = self._pcap_rx, start = False)
px.port_no = p.port_no
self.px[p.port_no] = px
self.log.setLevel(log_level)
for px in self.px.itervalues():
px.start()
self.t.start()
def __init__ (self, **kw):
"""
Create a switch instance
Additional options over superclass:
log_level (default to default_log_level) is level for this instance
ports is a list of interface names
"""
log_level = kw.pop('log_level', self.default_log_level)
self.q = Queue()
self.t = Thread(target=self._consumer_threadproc)
core.addListeners(self)
ports = kw.pop('ports', [])
kw['ports'] = []
super(PCapSwitch,self).__init__(**kw)
self._next_port = 1
self.px = {}
for p in ports:
self.add_interface(p, start=False)
self.log.setLevel(log_level)
for px in self.px.itervalues():
px.start()
self.t.start()
def __init__ (self, pusher_stream="pox"):
core.addListeners(self)
core.openflow.addListeners(self)
self.stream = pusher_stream
self.stopStatsThread = Event()
self.syncThread = TimerThread(self.stopStatsThread, request_stats, STAT_SAMPLING_PERIOD)
self.syncThread.start()
def __init__(self, filename): Timer(15, self.write_topology) self.net = core.thesis_topo self.filename = filename core.openflow.addListeners(self) core.addListeners(self)
def __init__(self, port = 6655, address = '0.0.0.0'):
Task.__init__(self)
self.port = int(port)
self.address = address
self.connection=None
#core.addListener(pox.core.GoingUpEvent, self._handle_GoingUpEvent)
core.addListeners(self)
def __init__(self):
# self._expire_timer = Timer(5, _handle_expiration, recurring=True)
# self.ip = IPAddr(input("Enter dummy IP Address: "))
# self.mac = EthAddr(input("Enter dummy MAC Address: "))
self.ip = IPAddr("10.0.0.100")
self.mac = EthAddr("00:11:22:33:44:55")
core.addListeners(self, priority=1)
self.hold_down_expired = _flood_delay == 0
def __init__(self):
# self._expire_timer = Timer(5, _handle_expiration, recurring=True)
# self.ip = IPAddr(input("Enter dummy IP Address: "))
# self.mac = EthAddr(input("Enter dummy MAC Address: "))
self.ip = IPAddr("10.0.0.100")
self.mac = EthAddr("00:11:22:33:44:55")
core.addListeners(self, priority=1)
self.hold_down_expired = _flood_delay == 0
def __init__(self):
# This timer handles expiring stuff
self._expire_timer = Timer(5, _handle_expiration, recurring=True)
self._arp_timer = Timer(3,
_arp_for_real_servers,
recurring=True,
selfStoppable=True)
core.addListeners(self)
def __init__(self):
self.groups = {}
self.incomplete_groups = {}
self.group_addrs = set()
self.member_state_builder = None
core.addListeners(self)
core.listen_to_dependencies(self, ['MemberStateBuilder'])
core.openflow.addListeners(self)
def __init__(self):
threading.Thread.__init__(self)
core.addListeners(self)
self._dataForConnection = {}
self._lock = threading.RLock()
self._waker = pox.lib.util.makePinger()
self.sending = False
self.start()
def __init__ (self):
threading.Thread.__init__(self)
core.addListeners(self)
self._dataForConnection = {}
self._lock = threading.RLock()
self._waker = pox.lib.util.makePinger()
self.sending = False
self.start()
def _all_dependencies_met(self):
"""
Called when every component on which depends are initialized on POX core.
Contain dependency relevant initialization.
:return: None
"""
try:
self.initialize()
# With fully event-driven communication between the layers the dependency
# handling takes care by listen_to_dependencies() run into a dead-lock.
# The root of this problem is the bidirectional or cyclic dependency
# between the components, so basically the layers will always wait to each
# other to be registered on core. To avoid this situation the naming
# convention of event handlers on which the dependency checking based is
# not followed (a.k.a. leave _handle_<component name>_<event name>) and
# the event listeners is set up manually. For automatic core registration
# the components have to contain dependencies explicitly.
for dep in self.dependencies:
if not self._standalone:
if core.core.hasComponent(dep):
dep_layer = core.components[dep]
# Register actual event handlers on dependent layer
dep_layer.addListeners(self)
# Register dependent layer's event handlers on actual layer
self.addListeners(dep_layer)
else:
raise AttributeError(
"Component is not registered on core")
else:
# In case of standalone mode set up a StandaloneHelper in this object
# with the name of the dependency to handle raised events
# automatically
setattr(self, dep, SimpleStandaloneHelper(self, dep))
# Subscribe for GoingDownEvent to finalize API classes
# shutdown() function will be called if POX's core going down
core.addListenerByName('GoingDownEvent', self.shutdown)
# Subscribe for UpEvent to call functions after everithing is up
core.addListenerByName('UpEvent', self.post_up_hook)
# Subscribe core event for advanced functions
# Listeners' name must follow POX naming conventions
core.addListeners(self)
# Everything is set up an "running" so register the component on pox.core
# as a final step. Other dependent component can finish initialization
# now.
core.core.register(self._core_name, self)
# Set "running" config for convenience purposes
CONFIG.set_layer_loaded(self._core_name)
except KeyboardInterrupt:
quit_with_error(
msg="Initialization of %s was interrrupted by user!" %
self.__class__.__name__)
except Exception as e:
quit_with_error(msg="Abort ESCAPEv2 initialization...",
exception=e)
def __init__(self):
"""
Initialise topology module.
"""
self.graph = nx.Graph()
self.ht = host_tracker.host_tracker()
core.openflow_discovery.addListeners(self)
self.listenTo(self.ht)
core.addListeners(self)
def __init__(self, connection, client_macs, **kwargs):
for name, value in kwargs.items():
setattr(self, name, value)
self.connection = connection
self.unacked = []
self.controlling = []
self.transport = PiloTransport(self, self.udp_ip, self.udp_port,
self.src_address,
self.retransmission_timeout,
self.heartbeat_interval)
for client_mac in client_macs:
self.transport.initiate_connection(client_mac)
# Creates an open flow rule which should send PILO broadcast messages
# to our handler
broadcast_msg_flow = of.ofp_flow_mod()
broadcast_msg_flow.priority = 100
broadcast_msg_flow.match.dl_type = pkt.ethernet.IP_TYPE
broadcast_msg_flow.match.nw_proto = pkt.ipv4.UDP_PROTOCOL
broadcast_msg_flow.match.nw_dst = IPAddr(
self.udp_ip) # TODO: better matching for broadcast IP
broadcast_msg_flow.actions.append(
of.ofp_action_output(port=of.OFPP_CONTROLLER))
self.connection.send(broadcast_msg_flow)
normal_msg_flow = of.ofp_flow_mod()
normal_msg_flow.priority = 101
normal_msg_flow.match.dl_type = pkt.ethernet.IP_TYPE
normal_msg_flow.match.dl_src = pkt.packet_utils.mac_string_to_addr(
get_hw_addr(self.this_if))
normal_msg_flow.match.nw_proto = pkt.ipv4.UDP_PROTOCOL
normal_msg_flow.match.nw_dst = IPAddr(
self.udp_ip) # TODO: better matching for broadcast IP
normal_msg_flow.actions.append(of.ofp_action_output(port=of.OFPP_ALL))
self.connection.send(normal_msg_flow)
# A Final rule to send any ovs rule misses to the controller
# I believe that OF 1.0 does this automatically, but later versions do not
table_miss_msg_flow = of.ofp_flow_mod()
table_miss_msg_flow.priority = 1
table_miss_msg_flow.actions.append(
of.ofp_action_output(port=of.OFPP_CONTROLLER))
self.connection.send(table_miss_msg_flow)
connection.addListeners(self, priority=99)
self.transport.addListeners(self)
core.addListeners(self, priority=99)
core.openflow.addListeners(self, priority=99)
def __init__ (self, port = 6655, address = '0.0.0.0'):
Task.__init__(self)
self.port = int(port)
self.address = address
self.connection=None
self.finallink=[]
self.switches = set()
self.adjacency = {}
core.addListeners(self)
core.openflow_discovery.addListeners(self)
core.openflow.addListeners(self)
def __init__ (self):
self.prev_change_port = None
self.log_file = open("/tmp/pox_log", "w")
self.barrier_log_file = open("/tmp/barrier_log", "w")
self._pending_barriers = {}
self._prev_barrier_arrived = {}
self._xid_generator = of.xid_generator()
core.openflow.addListeners(self)
core.Outband.addListeners(self)
core.addListeners(self)
super( ProactiveRouting, self ).__init__()
def __init__(self):
self.prev_change_port = None
self.log_file = open("/tmp/pox_log", "w")
self.barrier_log_file = open("/tmp/barrier_log", "w")
self._pending_barriers = {}
self._prev_barrier_arrived = {}
self._xid_generator = of.xid_generator()
core.openflow.addListeners(self)
core.Outband.addListeners(self)
core.addListeners(self)
super(ProactiveRouting, self).__init__()
def __init__(self, objective, preinstall):
Timer(30, self._update_flows)
#Timer(15, self._preinstall_rules)
self.flows = {}
self.net = core.thesis_topo
self.stats = core.thesis_stats
self.objective = objective
self.preinstall = preinstall
core.openflow.addListeners(self)
core.addListeners(self)
def __init__(self):
# (topology dependent)initialize arp and master table with host ip-mac
self._master_arp_table = {}
for i in range(1, 7):
ipaddr = "10.0.0.%s" % str(i)
mac = "00:00:00:00:00:0%s" % str(i)
self._master_arp_table[IPAddr(ipaddr)] = EthAddr(mac)
self._arp_table = {}
#(topology specific) dpid
self.S4 = 4
self.S5 = 5
core.addListeners(self)
def __init__(self,tor_num,core_num):
core.addListeners(self)
self.tor_list = set()
self.tor_addr_config= dict()
self.core_list = set()
for s in range(tor_num):
dpid = "00-00-%0.2x-00-00-00" % (s+1)
ip = "192.168.%i.254/24" % (s+1)
self.tor_list.add(dpid)
self.tor_addr_config[dpid] = ip
for s in range(core_num):
dpid = "10-00-%0.2x-00-00-00" % (s+1)
self.core_list.add(dpid)
def startup(self):
"""
Esta funcion se encarga de inicializar el controller
Agrega el controller como event handler para los eventos de
openflow y openflow_discovery
"""
core.openflow.addListeners(self)
core.openflow_discovery.addListeners(self)
core.host_tracker.addListeners(self)
core.addListeners(self)
core.openflow.addListenerByName("FlowRemoved",
self._handle_flow_removal)
log.info('Controller initialized')
def __init__ (self, host_tracker=False, pusher_stream="pox"):
core.listen_to_dependencies(self)
core.addListeners(self)
self.initModel()
self.stream = pusher_stream
if host_tracker:
# TODO: Don't seem to be getting host events at the moment?
log.info("Host tracking enabled")
host_tracker.addListenerByName("HostEvent", self.__handle_host_tracker_HostEvent)
self.stopSyncThread = Event()
self.syncThread = TimerThread(self.stopSyncThread, self.sync, 15)
self.syncThread.start()
def __init__(self, host_tracker=False, pusher_stream="pox"):
core.listen_to_dependencies(self)
core.addListeners(self)
self.initModel()
self.stream = pusher_stream
if host_tracker:
# TODO: Don't seem to be getting host events at the moment?
log.info("Host tracking enabled")
host_tracker.addListenerByName(
"HostEvent", self.__handle_host_tracker_HostEvent)
self.stopSyncThread = Event()
self.syncThread = TimerThread(self.stopSyncThread, self.sync, 15)
self.syncThread.start()
def __init__(self,no_flows,explicit_drop,validate_link_timeout,delete_link_timeout,flow_priority,ttl,send_cycle,send_lldp_cycle_interval,raise_link_event_cycle_interval):
self.install_flow = not no_flows
self.explicit_drop = explicit_drop
self.validate_link_timeout = validate_link_timeout
self.delete_link_timeout = delete_link_timeout
self.flow_priority = flow_priority
self.ttl = ttl
self.send_cycle = send_cycle
self.send_lldp_cycle_interval = send_lldp_cycle_interval
self.raise_link_event_cycle_interval = raise_link_event_cycle_interval
self.adjacency = Adjacency()
self._set_link_validate_timer(validate_link_timeout)
self.port_addr = dict()
core.addListeners(self)
core.Interactive.variables["link"] = self.adjacency
def __init__(self,
no_flow,
eat_packets,
default_request_src_mac=False,
default_reply_src_mac=None):
"""
Initialize
default_request_src_mac and default_reply_src_mac are the default source
MAC addresses for send_arp_request() and send_arp_reply().
"""
core.addListeners(self)
self._install_flow = not no_flow
self.eat_packets = eat_packets
self.default_request_src_mac = default_request_src_mac
self.default_reply_src_mac = default_reply_src_mac
def __init__(self, connection, transparent):
self.macToPort = {}
self.connection = connection
self.transparent = transparent
# for _handle_PacketIn to work
core.addListeners(self, priority = PRIORITY)
core.openflow.addListeners(self, priority = PRIORITY)
connection.addListeners(self, priority = PRIORITY)
# Rule for ARP
default_timout = OpF.OFP_FLOW_PERMANENT
msg = OpF.ofp_flow_mod()
msg.match = OpF.ofp_match(dl_type = pkt.ethernet.ARP_TYPE)
msg.idle_timeout = default_timout
msg.hard_timeout = default_timout
msg.priority = PRIORITY
msg.actions.append(OpF.ofp_action_output(port = OpF.OFPP_CONTROLLER))
self.connection.send(msg)
def __init__(self, objective, preinstall):
"""
Initialise multicommodity module.
objective: objective function for calculating routes
preinstall: list of flow rules to preinstall on switches
"""
Timer(30, self._update_flows)
self.flows = {}
self.net = core.thesis_topo
self.stats = core.thesis_stats
self.objective = objective
self.preinstall = preinstall
self.log_rules = False
self.done = False
core.openflow.addListeners(self)
core.addListeners(self)
def start(self):
assert self._thread is None
from pox.core import core
core.addListeners(self, weak=True)
if self.use_select:
try:
import select
except:
# Fall back
self.use_select = False
# Log warning?
if self.use_select:
self.blocking = False
self._thread = pcap_select_loop.add(self)
else:
self._thread = Thread(target=self._thread_func)
self._thread.start()
def __init__(self, connection, transparent):
self.macToPort = {}
self.connection = connection
self.transparent = transparent
# for _handle_PacketIn to work
core.addListeners(self, priority=PRIORITY)
core.openflow.addListeners(self, priority=PRIORITY)
connection.addListeners(self, priority=PRIORITY)
# Rule for ARP
default_timout = OpF.OFP_FLOW_PERMANENT
msg = OpF.ofp_flow_mod()
msg.match = OpF.ofp_match(dl_type=pkt.ethernet.ARP_TYPE)
msg.idle_timeout = default_timout
msg.hard_timeout = default_timout
msg.priority = PRIORITY
msg.actions.append(OpF.ofp_action_output(port=OpF.OFPP_CONTROLLER))
self.connection.send(msg)
def __init__(self, **kw):
"""
Create a switch instance
Additional options over superclass:
log_level (default to default_log_level) is level for this instance
ports is a list of interface names
"""
log_level = kw.pop('log_level', self.default_log_level)
self.policy = None
self.rx_q = Queue()
self.consumer_thread = Thread(target=self._consumer_threadproc)
self.tx_q = Queue()
self.producer_thread = Thread(target=self._producer_threadproc)
core.addListeners(self)
ports = kw.pop('ports', [])
kw['ports'] = []
self.policy_name = kw.pop("policy", '')
if self.policy_name:
load_policy(self, self.policy_name)
super(ProgSwitch, self).__init__(**kw)
self._next_port = 1
self.px = {}
for p in ports:
self.add_interface(p, start=False)
self.log.setLevel(log_level)
for px in self.px.itervalues():
px.start()
self.consumer_thread.start()
self.producer_thread.start()
def __init__(self,timeout,no_flow,eat_packets,no_learn,*args,**kwargs):
self.ARP_TIMEOUT = timeout
self.install_flow = not no_flow
self.eat_packets = eat_packets
self.learn = not no_learn
#buffer for packet stored in datapath
self.ipv4_buffers = dict()
self.arp_buffers = dict()
# This timer handles expiring stuff
self._expire_arp_table_timer = Timer(5, self._handle_arp_table_expiration,recurring=True)
self._expire_ipv4_buffer_timer = Timer(5, self._handle_ipv4_buffer_expiration,recurring=True)
self._expire_arp_buffer_timer = Timer(5, self._handle_arp_buffer_expiration,recurring=True)
# Listen to dependencies
core.addListeners(self)
def _listen_to_dependencies():
core.BaseUtil.addListeners(self,priority=100)
core.LLDPUtil.addListeners(self,priority=100)
core.call_when_ready(_listen_to_dependencies, ('BaseUtil','LLDPUtil'))
#Get SRPConfig
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
core.call_when_ready(_get_config,('SRPConfig',))
def __init__(self, name, main=None, **kwargs):
"""
Create a switch instance
log_level (default to default_log_level) is level for this instance
ports is a list of interface names
:param kwargs:
:return:
"""
super(ProgSwitch, self).__init__()
self.name = name
self.tables = None
self.policy = None
if main:
r_value = main()
if isinstance(r_value, Policy):
self.policy = r_value
elif isinstance(r_value, tuple) and len(r_value) == 2:
if not isinstance(r_value[0], tables): raise TypeError("Invalid tables")
self.tables = r_value[0]
if not isinstance(r_value[1], Policy): raise TypeError("Invalid policy")
self.policy = r_value[1]
else:
raise TypeError("Invalid target.datapath policy")
core.addListeners(self)
self.port_no = 1
self.ports = {}
self.q = Queue()
self.t = Thread(target=self._consumer_threadproc)
def __init__ (self):
# This timer handles expiring stuff
self._expire_timer = Timer(5, _handle_expiration, recurring=True)
core.addListeners(self)
def __init__(self, no_flow, eat_packets, use_port_mac=False):
core.addListeners(self)
self._install_flow = not no_flow
self.eat_packets = eat_packets
self.use_port_mac = use_port_mac
def __init__(self):
self._arp_table = {}
#initialize table
self._master_arp_table = {}
core.addListeners(self)
def __init__(self, connection): self.dict_pxpcap = defaultdict(lambda:defaultdict(lambda:[])) connection.addListeners(self) core.addListeners(self, weak=True)
def __init__ (self): # This timer handles expiring stuff self._expire_timer = Timer(5, _handle_expiration, recurring=True) core.listen_to_dependencies(self) core.addListeners(self, priority = 2)
def __init__(self):
self.first = True
core.openflow.addListeners(self)
core.addListeners(self)
def __init__(self, no_flow, eat_packets):
core.addListeners(self)
self._install_flow = not no_flow
self.eat_packets = eat_packets
def __init__(self):
self._arp_table = {}
self._master_arp_table = {}
core.addListeners(self)
def __init__(self):
self.groups = {}
core.addListeners(self)
core.openflow.addListeners(self)
def __init__(self, type='full'):
self.type = type
self.db = {}
core.openflow.addListeners(self)
core.addListeners(self)
def __init__(self):
log.info("HostController init...")
# core.listen_to_dependencies(self)
# core.openflow.addListeners(self)
core.addListeners(self)
log.info("Done.")
def __init__ (self): self.first = True core.openflow.addListeners(self) core.addListeners(self)
def __init__(self, topoFile, routingFile):
self.topoStruct = TopoStructure(topoFile)
self.routingConfig = routingFile
core.addListeners(self)
def __init__(self):
self.switches = {}
core.openflow.addListeners(self)
core.addListeners(self)
def __init__ (self, transparent): self.listenTo(core.openflow) core.addListeners(self) self.transparent = transparent
def __init__(self):
# This timer handles expiring stuff
self._expire_timer = Timer(5, _handle_expiration, recurring=True)
core.addListeners(self)
def __init__ (self, timeout = 10): self.timeout = timeout self._t = Timer(self.timeout, self._check_timeouts, recurring=True) core.addListeners(self) core.host_tracker.addListeners(self)
