adding TestON
diff --git a/TestON/lib/pox/core.py b/TestON/lib/pox/core.py
new file mode 100644
index 0000000..8b31e7a
--- /dev/null
+++ b/TestON/lib/pox/core.py
@@ -0,0 +1,349 @@
+# Copyright 2011 James McCauley
+#
+# This file is part of POX.
+#
+# POX is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# POX is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with POX.  If not, see <http://www.gnu.org/licenses/>.
+
+"""
+Some of POX's core API and functionality is here, largely in the POXCore
+class (an instance of which is available as pox.core.core).
+
+This includes things like component rendezvous, logging, system status
+(up and down events), etc.
+"""
+
+# Set up initial log state
+import logging
+
+import inspect
+import time
+import os
+
+_path = inspect.stack()[0][1]
+_ext_path = _path[0:_path.rindex(os.sep)]
+_ext_path = os.path.dirname(_ext_path) + os.sep
+_path = os.path.dirname(_path) + os.sep
+
+SQUELCH_TIME = 5
+
+_squelch = ''
+_squelchTime = 0
+_squelchCount = 0
+
+def getLogger (name=None, moreFrames=0):
+  """
+  In general, you don't need to call this directly, and will use
+  core.getLogger() instead.
+  """
+  if name is None:
+    s = inspect.stack()[1+moreFrames]
+    name = s[1]
+    if name.endswith('.py'):
+      name = name[0:-3]
+    elif name.endswith('.pyc'):
+      name = name[0:-4]
+    if name.startswith(_path):
+      name = name[len(_path):]
+    elif name.startswith(_ext_path):
+      name = name[len(_ext_path):]
+    name = name.replace('/', '.').replace('\\', '.') #FIXME: use os.path or whatever
+
+    # Remove double names ("topology.topology" -> "topology")
+    if name.find('.') != -1:
+      n = name.split('.')
+      if len(n) >= 2:
+        if n[-1] == n[-2]:
+          del n[-1]
+          name = '.'.join(n)
+
+    if name.endswith(".__init__"):
+      name = name.rsplit(".__init__",1)[0]
+
+  l = logging.getLogger(name)
+  g=globals()
+  if not hasattr(l, "print"):
+    def printmsg (*args, **kw):
+      #squelch = kw.get('squelch', True)
+      msg = ' '.join((str(s) for s in args))
+      s = inspect.stack()[1]
+      o = '['
+      if 'self' in s[0].f_locals:
+        o += s[0].f_locals['self'].__class__.__name__ + '.'
+      o += s[3] + ':' + str(s[2]) + '] '
+      o += msg
+      if o == _squelch:
+        if time.time() >= _squelchTime:
+          l.debug("[Previous message repeated %i more times]" % (g['_squelchCount']+1,))
+          g['_squelchCount'] = 0
+          g['_squelchTime'] = time.time() + SQUELCH_TIME
+        else:
+          g['_squelchCount'] += 1
+      else:
+        g['_squelch'] = o
+        if g['_squelchCount'] > 0:
+          l.debug("[Previous message repeated %i more times]" % (g['_squelchCount'],))
+        g['_squelchCount'] = 0
+        g['_squelchTime'] = time.time() + SQUELCH_TIME
+        l.debug(o)
+
+    setattr(l, "print", printmsg)
+    setattr(l, "msg", printmsg)
+
+  return l
+
+
+log = (lambda : getLogger())()
+
+from pox.lib.revent import *
+
+# Now use revent's exception hook to put exceptions in event handlers into
+# the log...
+def _revent_exception_hook (source, event, args, kw, exc_info):
+  try:
+    c = source
+    t = event
+    if hasattr(c, "__class__"): c = c.__class__.__name__
+    if isinstance(t, Event): t = t.__class__.__name__
+    elif issubclass(t, Event): t = t.__name__
+  except:
+    pass
+  log.exception("Exception while handling %s!%s...\n" % (c,t))
+import pox.lib.revent.revent
+pox.lib.revent.revent.handleEventException = _revent_exception_hook
+
+class GoingUpEvent (Event):
+  """ Fired when system is going up. """
+  pass
+
+class GoingDownEvent (Event):
+  """ Fired when system is going down. """
+  pass
+
+class UpEvent (Event):
+  """ Fired when system is up. """
+  pass
+
+class DownEvent (Event):
+  """ Fired when system is down. """
+  pass
+
+class ComponentRegistered (Event):
+  """
+  This is raised by core whenever a new component is registered.
+  By watching this, a component can monitor whether other components it
+  depends on are available.
+  """
+  def __init__ (self, name, component):
+    Event.__init__(self)
+    self.name = name
+    self.component = component
+
+import pox.lib.recoco as recoco
+
+class POXCore (EventMixin):
+  """
+  A nexus of of the POX API.
+
+  pox.core.core is a reference to an instance of this class.  This class
+  serves a number of functions.
+
+  An important one is that it can serve as a rendezvous point for
+  components.  A component can register objects on core, and they can
+  then be accessed on the core object (e.g., if you register foo, then
+  there will then be a pox.core.core.foo).  In many cases, this means you
+  won't need to import a module.
+
+  Another purpose to the central registration is that it decouples
+  functionality from a specific module.  If myL2Switch and yourL2Switch
+  both register as "switch" and both provide the same API, then it doesn't
+  matter.  Doing this with imports is a pain.
+
+  Additionally, a number of commmon API functions are vailable here.
+  """
+  _eventMixin_events = set([
+    UpEvent,
+    DownEvent,
+    GoingUpEvent,
+    GoingDownEvent,
+    ComponentRegistered
+  ])
+
+  def __init__ (self):
+    self.debug = False
+    self.running = True
+    self.components = {}
+
+    self.version = (0,0,0)
+    print "{0} / Copyright 2011 James McCauley".format(self.version_string)
+
+    self.scheduler = recoco.Scheduler(daemon=True)
+
+  @property
+  def version_string (self):
+    return "POX " + '.'.join(map(str, self.version))
+
+  def callDelayed (_self, _seconds, _func, *args, **kw):
+    """
+    Calls the function at a later time.
+    This is just a wrapper around a recoco timer.
+    """
+    t = recoco.Timer(_seconds, _func, args=args, kw=kw,
+                     scheduler = _self.scheduler)
+    return t
+
+  def callLater (_self, _func, *args, **kw):
+    # first arg is `_self` rather than `self` in case the user wants
+    # to specify self as a keyword argument
+    """
+    Call the given function with the given arguments within the context
+    of the co-operative threading environment.
+    It actually calls it sooner rather than later. ;)
+    Much of POX is written without locks because it's all thread-safe
+    with respect to itself, as it's written using the recoco co-operative
+    threading library.  If you have a real thread outside of the
+    co-operative thread context, you need to be careful about calling
+    things within it.  This function provides a rather simple way that
+    works for most situations: you give it a callable (like a method)
+    and some arguments, and it will call that callable with those
+    arguments from within the co-operative threader, taking care of
+    synchronization for you.
+    """
+    _self.scheduler.callLater(_func, *args, **kw)
+
+  def raiseLater (_self, _obj, *args, **kw):
+    # first arg is `_self` rather than `self` in case the user wants
+    # to specify self as a keyword argument
+    """
+    This is similar to callLater(), but provides an easy way to raise a
+    revent event from outide the co-operative context.
+    Rather than foo.raiseEvent(BarEvent, baz, spam), you just do
+    core.raiseLater(foo, BarEvent, baz, spam).
+    """
+    _self.scheduler.callLater(_obj.raiseEvent, *args, **kw)
+
+  def getLogger (self, *args, **kw):
+    """
+    Returns a logger.  Pass it the name you want if you'd like to specify
+    one (e.g., core.getLogger("foo")).  If you don't specify a name, it
+    will make one up based on the module name it is called from.
+    """
+    return getLogger(moreFrames=1,*args, **kw)
+
+  def quit (self):
+    """
+    Shut down POX.
+    """
+    if self.running:
+      self.running = False
+      log.info("Going down...")
+      import gc
+      gc.collect()
+      self.raiseEvent(GoingDownEvent())
+      self.callLater(self.scheduler.quit)
+      for i in range(50):
+        if self.scheduler._hasQuit: break
+        gc.collect()
+        time.sleep(.1)
+      if not self.scheduler._allDone:
+        log.warning("Scheduler didn't quit in time")
+      self.raiseEvent(DownEvent())
+      log.info("Down.")
+
+  def goUp (self):
+    log.debug(self.version_string + " going up...")
+
+    import platform
+    py = "{impl} ({vers}/{build})".format(
+     impl=platform.python_implementation(),
+     vers=platform.python_version(),
+     build=platform.python_build()[1].replace("  "," "))
+    log.debug("Running on " + py)
+
+    self.raiseEvent(GoingUpEvent())
+    log.info(self.version_string + " is up.")
+    self.raiseEvent(UpEvent())
+
+  def hasComponent (self, name):
+    """
+    Returns True if a component with the given name has been registered.
+    """
+    return name in self.components
+
+  def registerNew (self, __componentClass, *args, **kw):
+    """
+    Give it a class (and optional __init__ arguments), and it will
+    create an instance and register it using the class name.  If the
+    instance has a _core_name property, it will use that instead.
+    It returns the new instance.
+    core.registerNew(FooClass, arg) is roughly equivalent to
+    core.register("FooClass", FooClass(arg)).
+    """
+    name = __componentClass.__name__
+    obj = __componentClass(*args, **kw)
+    if hasattr(obj, '_core_name'):
+      # Default overridden
+      name = obj._core_name
+    self.register(name, obj)
+    return obj
+
+  def register (self, name, component):
+    """
+    Makes the object "component" available as pox.core.core.name.
+    """
+    #TODO: weak references?
+    if name in self.components:
+      log.warn("Warning: Registered '%s' multipled times" % (name,))
+    self.components[name] = component
+    self.raiseEventNoErrors(ComponentRegistered, name, component)
+    
+  def listenToDependencies(self, sink, components):
+    """
+    If a component depends on having other components
+    registered with core before it can boot, it can use this method to 
+    check for registration, and listen to events on those dependencies.
+    
+    Note that event handlers named with the _handle* pattern in the sink must
+    include the name of the desired source as a prefix. For example, if topology is a
+    dependency, a handler for topology's SwitchJoin event must be labeled:
+       def _handle_topology_SwitchJoin(...)
+    
+    sink - the component waiting on dependencies
+    components - a list of dependent component names
+    
+    Returns whether all of the desired components are registered.
+    """
+    if components == None or len(components) == 0:
+      return True
+  
+    got = set()
+    for c in components:
+      if self.hasComponent(c):
+        setattr(sink, c, getattr(self, c))
+        sink.listenTo(getattr(self, c), prefix=c)
+        got.add(c)
+      else:
+        setattr(sink, c, None)
+    for c in got:
+      components.remove(c)
+    if len(components) == 0:
+      log.debug(sink.__class__.__name__ + " ready")
+      return True
+    return False
+
+  def __getattr__ (self, name):
+    if name not in self.components:
+      raise AttributeError("'%s' not registered" % (name,))
+    return self.components[name]
+
+core = POXCore()