def __init__(self, configfilename):
self.connection = None
self.config = None
self.read_config(configfilename)
core.openflow.addListeners(self)
core.addListenerByName("GoingDownEvent", self._handle_GoingDownEvent)
log.info("Launch complete, waiting for OF connection...")
def launch(standalone=False, address='127.0.0.1', port=6633, max_retry_delay=16,
dpid=None, ports='', policy='', extra=None, ctl_port=None,
__INSTANCE__=None):
"""
Launches a switch
"""
if not pxpcap.enabled:
raise RuntimeError("You need PXPCap to use this component")
if ctl_port:
if core.hasComponent('ctld'):
raise RuntimeError("Only one ctl_port is allowed")
if ctl_port is True:
ctl_port = DEFAULT_CTL_PORT
from pox.datapaths import ctl
ctl.server(ctl_port)
core.ctld.addListenerByName("CommandEvent", _do_ctl)
_ports = ports.strip()
def up(event):
ports = [p for p in _ports.split(",") if p]
switch = do_launch(ProgSwitch, standalone, address, port, max_retry_delay, dpid,
ports=ports, policy=policy, extra_args=extra)
_switches[switch.name] = switch
core.addListenerByName("UpEvent", up)
def launch (foo = False, bar = False):
component = AlienComponent("demo1")
core.register("alien", component)
core.addListenerByName("UpEvent", _go_up)
def launch(sg_file=None,
config=None,
gui=False,
agent=False,
rosapi=False,
full=False,
loglevel="INFO",
cfor=False,
visualization=False,
mininet=None,
test=False,
log=None,
quit=False):
"""
Launch function called by POX core when core is up.
:param sg_file: Path of the input Service graph (optional)
:type sg_file: str
:param config: additional config file with different name
:type config: str
:param gui: Signal for initiate GUI (optional)
:type gui: bool
:param agent: Do not start the service layer (optional)
:type agent: bool
:param rosapi:
:param full: Initiate Infrastructure Layer also
:type full: bool
:param loglevel: run on specific run level (default: INFO)
:type loglevel: str
:param cfor: start Cf-Or REST API (optional)
:type cfor: bool
:param visualization: send NFFGs to remote visualization server (optional)
:type visualization: bool
:param mininet: Path of the initial topology graph (optional)
:type mininet: str
:param test: Start ESCAPE in test mode (optional)
:type test: bool
:param log: add ESCAPE main log file for test mode (default: log/escape.log)
:type log: str
:param quit: Quit after the first service request has processed (optional)
:type quit: bool
:return: None
"""
# Store args into this module file
global init_param
init_param.update(locals())
__setup_pythonpath()
__init_loggers(loglevel=loglevel, log=log, test=test)
__init_config(config=config, test=test, quit=quit)
__print_header()
if visualization:
core_log.debug("Enable remote visualization...")
from escape.util.com_logger import RemoteVisualizer
core.register(RemoteVisualizer._core_name, RemoteVisualizer())
# Register _start_components() to be called when POX is up
core.addListenerByName("GoingUpEvent", _start_components)
def launch (**kw):
__main__.cli = False # Disable CLI
global _first
if _first:
core.addListenerByName("UpEvent", _up)
_first = False
for k in kw:
if k not in _tests:
_tests.append(k)
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 launch():
def set_miss_length(event=None):
if not core.hasComponent('openflow'):
return
core.openflow.miss_send_len = 0x7fff
core.getLogger().info("Requesting full packet payloads")
return EventRemove
if set_miss_length() is None:
core.addListenerByName("ComponentRegistered", set_miss_length)
def launch ():
"""
The default launcher just logs its arguments
"""
#log.warn("Foo: %s (%s)", foo, type(foo))
#log.warn("Bar: %s (%s)", bar, type(bar))
core.addListenerByName("UpEvent", _go_up)
core.registerNew(sine_event) #DJ++ 20121223
def launch (foo, bar = False):
"""
The default launcher just logs its arguments
"""
print "test"
log.warn("Foo: %s (%s)", foo, type(foo))
log.warn("Bar: %s (%s)", bar, type(bar))
core.addListenerByName("UpEvent", _go_up)
def realStart (event=None):
if not core.hasComponent("messenger"):
if event is None:
# Only do this the first time
log.warning("Deferring firing up LogMessenger because Messenger isn't up yet")
core.addListenerByName("ComponentRegistered", realStart, once=True)
return
global logMessengerListener
logMessengerListener = LogMessengerListener()
log.info("Up...")
def launch ():
def set_miss_length (event = None):
if not core.hasComponent('openflow'):
return
core.openflow.miss_send_len = 0x7fff
core.getLogger().info("Requesting full packet payloads")
return EventRemove
if set_miss_length() is None:
core.addListenerByName("ComponentRegistered", set_miss_length)
def realStart (event=None):
if not core.hasComponent("messenger"):
if event is None:
# Only do this the first time
log.warning("Deferring firing up GuiMessengerServiceListener because Messenger isn't up yet")
core.addListenerByName("ComponentRegistered", realStart, once=True)
return
if not core.hasComponent(GuiMessengerServiceListener.__name__):
core.registerNew(GuiMessengerServiceListener)
log.info("Up...")
def realStart(event=None):
if not core.hasComponent("messenger"):
if event is None:
# Only do this the first time
log.warning(
"Deferring firing up LogMessenger because Messenger isn't up yet"
)
core.addListenerByName("ComponentRegistered", realStart, once=True)
return
global logMessengerListener
logMessengerListener = LogMessengerListener()
log.info("Up...")
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 ():
def _handle_ConnectionUp (event):
#log.debug("Connection %s" % (event.connection,))
gw = EE122Gateway(event.connection, event.ofp.ports)
core.register("gateway", gw)
#gw.addListeners(Controller())
core.openflow.addListenerByName("ConnectionUp", _handle_ConnectionUp)
def _handle_reg (event):
if event.name == "gateway":
try:
from firewall import Firewall
event.component.addListeners(Firewall())
except:
fw_log.exception("Couldn't load firewall.py")
core.addListenerByName("ComponentRegistered", _handle_reg)
def launch (address='', port=8000, static=False):
httpd = SplitThreadedServer((address, int(port)), SplitterRequestHandler)
core.register("WebServer", httpd)
httpd.set_handler("/", CoreHandler, httpd, True)
#httpd.set_handler("/foo", StaticContentHandler, {'root':'.'}, True)
#httpd.set_handler("/f", StaticContentHandler, {'root':'pox'}, True)
#httpd.set_handler("/cgis", SplitCGIRequestHandler, "pox/web/www_root")
if static is True:
httpd.add_static_dir('static', 'www_root', relative=True)
elif static is False:
pass
else:
static = static.split(",")
for entry in static:
if entry.lower() == "":
httpd.add_static_dir('static', 'www_root', relative=True)
continue
if ':' not in entry:
directory = entry
prefix = os.path.split(directory)
if prefix[1] == '':
prefix = os.path.split(prefix[0])
prefix = prefix[1]
assert prefix != ''
else:
prefix,directory = entry.split(":")
directory = os.path.expanduser(directory)
httpd.add_static_dir(prefix, directory, relative=False)
def run ():
try:
log.debug("Listening on %s:%i" % httpd.socket.getsockname())
httpd.serve_forever()
except:
pass
log.info("Server quit")
def go_up (event):
thread = threading.Thread(target=run)
thread.daemon = True
thread.start()
def go_down (event):
httpd.shutdown()
core.addListenerByName("GoingUpEvent", go_up)
core.addListenerByName("GoingDownEvent", go_down)
def launch (fakeways="", arp_for_unknowns=None):
def set_miss_length (event = None):
if not core.hasComponent('openflow'):
return
core.openflow.miss_send_len = 0x7fff
core.getLogger().info("Requesting full packet payloads")
return EventRemove
if set_miss_length() is None:
core.addListenerByName("ComponentRegistered", set_miss_length)
fakeways = fakeways.replace(","," ").split()
fakeways = [IPAddr(x) for x in fakeways]
if arp_for_unknowns is None:
arp_for_unknowns = len(fakeways) > 0
else:
arp_for_unknowns = str_to_bool(arp_for_unknowns)
core.registerNew(l3_switch, fakeways, arp_for_unknowns)
def launch(fakeways="", arp_for_unknowns=None):
def set_miss_length(event=None):
if not core.hasComponent('openflow'):
return
core.openflow.miss_send_len = 0x7fff
core.getLogger().info("Requesting full packet payloads")
return EventRemove
if set_miss_length() is None:
core.addListenerByName("ComponentRegistered", set_miss_length)
fakeways = fakeways.replace(",", " ").split()
fakeways = [IPAddr(x) for x in fakeways]
if arp_for_unknowns is None:
arp_for_unknowns = len(fakeways) > 0
else:
arp_for_unknowns = str_to_bool(arp_for_unknowns)
core.registerNew(l3_switch, fakeways, arp_for_unknowns)
def launch (address = '127.0.0.1', port = 6633, max_retry_delay = 16,
dpid = None, ports = '', extra = None, __INSTANCE__ = None):
"""
Launches a switch
"""
if not pxpcap.enabled:
raise RuntimeError("You need PXPCap to use this component")
_ports = ports
def up (event):
devs = pxpcap.PCap.get_devices()
ports = _ports.split(",")
phys = []
portnum = 1
if len(ports) == 1 and ports[0] == '': ports = []
for p in list(ports):
if p not in devs:
log.error("Device %s not available -- ignoring", p)
continue
dev = devs[p]
if dev.get('addrs',{}).get('ethernet',{}).get('addr') is None:
log.error("Device %s has no ethernet address -- ignoring", p)
continue
if dev.get('addrs',{}).get('AF_INET') != None:
log.error("Device %s has an IP address -- ignoring", p)
continue
phy = of.ofp_phy_port()
phy.port_no = portnum
portnum += 1
phy.hw_addr = dev['addrs']['ethernet']['addr']
phy.name = p
# Fill in features sort of arbitrarily
phy.curr = of.OFPPF_10MB_HD
phy.advertised = of.OFPPF_10MB_HD
phy.supported = of.OFPPF_10MB_HD
phy.peer = of.OFPPF_10MB_HD
phys.append(phy)
do_launch(PCapSwitch, address, port, max_retry_delay, dpid, ports=phys,
extra_args=extra)
core.addListenerByName("UpEvent", up)
def launch(mode=1, wordslist="badwords.txt", gateway_mac="00-00-00-00-00-00"):
"""
The default launcher that intercepts PacketIn events
Modes:
1 - hold on controller util classification ends
2 - inspect on controller but allow forwarding to edge switch
"""
global _mode
_mode = mode
# _gateway_mac = EthAddr(gateway_mac)
log.info("Mode is {}".format(_mode))
try:
_load_wordslist(wordslist)
except Exception as e:
log.error(e.message)
log.error('All packets will be marked as "valid"')
while True:
opt = raw_input("Do you want to continue (y/n)? ")
if opt == "y":
break
elif opt == "n":
log.error("Operation terminated")
sys.exit(-1)
if _set_miss_length() is None:
core.addListenerByName("ComponentRegistered", _set_miss_length)
core.openflow.addListenerByName("ConnectionUp", _register_last_switch)
if _mode == 1:
core.openflow.addListenerByName("PacketIn", _packet_handler_mode1)
elif _mode == 2:
core.openflow.addListenerByName("PacketIn", _packet_handler_mode2)
else:
log.error("Invalid mode")
sys.exit(-2)
