def __init__(self,
worker_start,
matchers=(),
scheduler=None,
mp=True,
inputlimit=0,
allowcontrol=True):
'''
:param worker_start: func(queuein, queueout), queuein is the input queue, queueout is the
output queue. For queuein, each object is (event, matcher) tuple; For queueout, each
object is a tuple of events to send. Every object in queuein must have a response in
queueout.
:param matcheres: match events to be processed by connector.
:param scheduler: bind to specified scheduler
:param mp: use multiprocessing if possible. For windows, multi-threading is always used.
:param inputlimit: input queue size limit. 0 = infinite.
:param allowcontrol: if True, the connector accepts ConnectorControlEvent for connector configuration.
'''
RoutineContainer.__init__(self, scheduler, True)
self.worker_start = worker_start
self.matchers = set(matchers)
self.mp = mp
self.inputlimit = inputlimit
self.allowcontrol = allowcontrol
self.stopreceive = False
self.jobs = 0
self._moreresult_matcher = MoreResultEvent.createMatcher()
def __init__(self, moduleinst, apidefs = None, allowdiscover = True, rejectunknown = True):
RoutineContainer.__init__(self, scheduler=moduleinst.scheduler, daemon=False)
self.handler = EventHandler(self.scheduler)
self.servicename = moduleinst.getServiceName()
self.apidefs = apidefs
self.registeredAPIs = {}
self.discoverinfo = {}
self.allowdiscover = allowdiscover
self.rejectunknown = rejectunknown
def __init__(self, moduleinst, apidefs = None, allowdiscover = True, rejectunknown = True):
RoutineContainer.__init__(self, scheduler=moduleinst.scheduler, daemon=False)
self.handler = EventHandler(self.scheduler)
self.servicename = moduleinst.getServiceName()
self.apidefs = apidefs
self.registeredAPIs = {}
self.discoverinfo = {}
self.allowdiscover = allowdiscover
self.rejectunknown = True
def __init__(self, vhostbind, prefix, scheduler=None, singlecastlimit = 256, deflate = False):
RoutineContainer.__init__(self, scheduler=scheduler, daemon=False)
self.vhostbind = vhostbind
self.prefix = _bytes(prefix)
self._matchers = {}
self._publishkey = uuid.uuid1().hex
self._publishno = 1
self._publish_wait = set()
self._matchadd_wait = set()
self._matchremove_wait = set()
self._singlecastlimit = singlecastlimit
self._deflate = deflate
def __init__(self,
connection,
initialkeys=(),
requestid=None,
logger=None):
"""
Retrieve data objects from ObjectDB and use them to generate flows
The module starts ObjectDB.walk from initial keys and walkers. After the
walk completes, the retrieved data objects are used by `updateflow()` to
generate flows and send them to the OpenFlow connection. When the retrieved
objects are updated, FlowUpdater either restart the walk process (re-walk)
or directly call another `updateflow()`, according to the objects that are updated.
A subclass should re-initialize `self._initialkeys` and `self._walkerdict`
before `main()` coroutine starts to customize the process.
`updateflow()` is guaranteed for no re-entrance i.e. will not be called until
the last call returns. Multiple changes may be merged into the same call.
:param connection: OpenFlow connection
:param initialkeys: DEPRECATED The key list that triggers a re-walk
:param requestid: request id to retrieve data objects from ObjectDB
:param logger: inherit a logger from a module
"""
RoutineContainer.__init__(self, connection.scheduler)
# When keys in this sequence are updated, start re-walk
self._initialkeys = initialkeys
self._connection = connection
# Walker dict, will be re-initialized by a subclass
self._walkerdict = {}
# Walk result
self._savedkeys = ()
self._savedresult = []
# Update notification (with a cache for synchronize)
self._updatedset = set()
self._updatedset2 = set()
if not logger:
self._logger = logging.getLogger(__name__ + '.FlowUpdater')
else:
self._logger = logger
if requestid is None:
self._requstid = str(uuid1())
else:
self._requstid = requestid
self._requestindex = 0
# Detect data object updates
self._dataupdateroutine = None
# Calling updateflow() in the same routine to prevent a re-entrance
self._flowupdateroutine = None
def __init__(self,
vhostbind,
prefix,
scheduler=None,
singlecastlimit=256,
deflate=False):
RoutineContainer.__init__(self, scheduler=scheduler, daemon=False)
self.vhostbind = vhostbind
self.prefix = _bytes(prefix)
self._matchers = {}
self._publishkey = uuid.uuid1().hex
self._publishno = 1
self._publish_wait = set()
self._matchadd_wait = set()
self._matchremove_wait = set()
self._singlecastlimit = singlecastlimit
self._deflate = deflate
def __init__(self, connection, initialkeys, requestid=None, logger=None):
RoutineContainer.__init__(self, connection.scheduler)
self._initialkeys = initialkeys
self._connection = connection
self._walkerdict = {}
self._savedkeys = ()
self._savedresult = []
self._updatedset = set()
self._updatedset2 = set()
if not logger:
self._logger = logging.getLogger(__name__ + '.FlowUpdater')
else:
self._logger = logger
if requestid is None:
self._requstid = str(uuid1())
else:
self._requstid = requestid
self._dataupdateroutine = None
self._flowupdateroutine = None
def __init__(self, connection, initialkeys, requestid = None, logger = None):
RoutineContainer.__init__(self, connection.scheduler)
self._initialkeys = initialkeys
self._connection = connection
self._walkerdict = {}
self._savedkeys = ()
self._savedresult = []
self._updatedset = set()
self._updatedset2 = set()
if not logger:
self._logger = logging.getLogger(__name__ + '.FlowUpdater')
else:
self._logger = logger
if requestid is None:
self._requstid = str(uuid1())
else:
self._requstid = requestid
self._dataupdateroutine = None
self._flowupdateroutine = None
def __init__(self, worker_start, matchers=(), scheduler=None, mp=True, inputlimit=0, allowcontrol=True):
"""
:param worker_start: func(queuein, queueout), queuein is the input queue, queueout is the
output queue. For queuein, each object is (event, matcher) tuple; For queueout, each
object is a tuple of events to send. Every object in queuein must have a response in
queueout.
:param matcheres: match events to be processed by connector.
:param scheduler: bind to specified scheduler
:param mp: use multiprocessing if possible. For windows, multi-threading is always used.
:param inputlimit: input queue size limit. 0 = infinite.
:param allowcontrol: if True, the connector accepts ConnectorControlEvent for connector configuration.
"""
RoutineContainer.__init__(self, scheduler, True)
self.worker_start = worker_start
self.matchers = set(matchers)
self.mp = mp
self.inputlimit = inputlimit
self.allowcontrol = allowcontrol
self.stopreceive = False
self.jobs = 0
self._moreresult_matcher = MoreResultEvent.createMatcher()
def __init__(self, connection, passive):
scheduler = connection.scheduler
RoutineContainer.__init__(self, scheduler)
self.passive = passive
self.connection = connection
def __init__(self, connection, passive):
scheduler = connection.scheduler
RoutineContainer.__init__(self, scheduler)
self.passive = passive
self.connection = connection
def __init__(self, scheduler=None, daemon=False, vhost=''):
RoutineContainer.__init__(self, scheduler=scheduler, daemon=daemon)
self.dispatcher = Dispatcher(scheduler, daemon, vhost)
def __init__(self, server):
self.server = server
RoutineContainer.__init__(self, scheduler=server.scheduler, daemon=True)
self.activeModules = {}
def __init__(self, server):
self.server = server
RoutineContainer.__init__(self, scheduler=server.scheduler, daemon=True)
self.activeModules = {}
def __init__(self, client, scheduler=None, daemon=False):
RoutineContainer.__init__(self, scheduler=scheduler, daemon=daemon)
self.client = client
def __init__(self, client, scheduler=None, daemon=False):
RoutineContainer.__init__(self, scheduler=scheduler, daemon=daemon)
self.client = client