def _test_limiter(limit, expected_result, *numbers):
scheduler = Scheduler()
rA = RoutineContainer(scheduler)
rB = RoutineContainer(scheduler)
limiter = RateLimiter(limit, rA)
counter = [0, 0]
result = []
async def _record():
first = True
while True:
await rA.do_events()
if counter[0] == 0:
break
result.append((counter[0], counter[1]))
counter[0] = 0
counter[1] = 0
async def _limited(use = 1):
await limiter.limit(use)
counter[0] += 1
counter[1] += use
async def _starter():
for t in numbers:
if isinstance(t, tuple):
for use in t:
rB.subroutine(_limited(use))
else:
for _ in range(t):
rB.subroutine(_limited())
await rB.do_events()
rA.subroutine(_record(), False)
rB.subroutine(_starter())
scheduler.main()
self.assertEqual(result, expected_result)
def testSelfConnectionUdp(self):
c1 = Client('udp://localhost:199', self.protocolClient, self.scheduler)
c2 = Client('pudp://localhost:199', self.protocolServer,
self.scheduler)
r = RoutineContainer(self.scheduler, True)
ret = bytearray()
def mainA():
m = TestDataEvent.createMatcher()
while True:
yield (m, )
if r.event.connection is c2:
ret.extend(b'A')
else:
ret.extend(b'B')
r.main = mainA
r.start()
def waitAndStart(c):
for m in r.waitWithTimeout(0.5):
yield m
c.start()
r.subroutine(waitAndStart(c1))
c2.start()
self.scheduler.main()
self.assertEqual(ret, b'ABABABABABABABABABAB')
def testSemaphore(self):
rc = RoutineContainer(self.server.scheduler)
obj = [0]
def routineLock(key):
l = Lock(key, rc.scheduler)
for m in l.lock(rc):
yield m
t = obj[0]
for m in rc.waitWithTimeout(0.5):
yield m
obj[0] = t + 1
l.unlock()
def main_routine():
smp = Semaphore('testobj', 2, rc.scheduler)
smp.create()
for m in rc.executeAll([routineLock('testobj'),
routineLock('testobj'),
routineLock('testobj'),
routineLock('testobj')], retnames = ()):
yield m
for m in smp.destroy(rc):
yield m
rc.subroutine(main_routine())
self.server.serve()
self.assertEqual(obj[0], 2)
def testSemaphore(self):
rc = RoutineContainer(self.server.scheduler)
obj = [0]
async def routineLock(key):
l = Lock(key, rc.scheduler)
await l.lock(rc)
t = obj[0]
await rc.do_events()
obj[0] = t + 1
l.unlock()
async def main_routine():
smp = Semaphore('testobj', 2, rc.scheduler)
smp.create()
await rc.execute_all([
routineLock('testobj'),
routineLock('testobj'),
routineLock('testobj'),
routineLock('testobj')
])
await smp.destroy(rc)
rc.subroutine(main_routine())
self.server.serve()
self.assertEqual(obj[0], 2)
def __init__(self, server):
Module.__init__(self, server)
self._managed_objs = {}
self._watches = {}
self._watchedkeys = set()
self._requests = []
self._transactno = 0
self._stale = False
self._updatekeys = set()
self._update_version = {}
self.apiroutine = RoutineContainer(self.scheduler)
self.apiroutine.main = self._update
self.routines.append(self.apiroutine)
self.createAPI(api(self.mget, self.apiroutine),
api(self.get, self.apiroutine),
api(self.mgetonce, self.apiroutine),
api(self.getonce, self.apiroutine),
api(self.mwatch, self.apiroutine),
api(self.watch, self.apiroutine),
api(self.munwatch, self.apiroutine),
api(self.unwatch, self.apiroutine),
api(self.transact, self.apiroutine),
api(self.watchlist),
api(self.walk, self.apiroutine)
)
def testServerClientSsl(self):
c1 = Client('ssl://localhost:199', self.protocolClient, self.scheduler, 'testcerts/client.key', 'testcerts/client.crt', 'testcerts/root.crt')
s1 = TcpServer('lssl://localhost:199', self.protocolServer, self.scheduler, 'testcerts/server.key', 'testcerts/server.crt', 'testcerts/root.crt')
r = RoutineContainer(self.scheduler, True)
ret = bytearray()
def mainA():
m = TestDataEvent.createMatcher()
stopped = False
while True:
yield (m,)
if r.event.connection is c1:
ret.extend(b'B')
else:
ret.extend(b'A')
if not stopped:
for m in s1.shutdown():
yield m
stopped = True
r.main = mainA
r.start()
s1.start()
def waitAndStart(c):
for m in r.waitWithTimeout(0.5):
yield m
c.start()
r.subroutine(waitAndStart(c1))
self.scheduler.main()
self.assertEqual(ret, b'ABABABABABABABABABAB')
def __init__(self, server):
Module.__init__(self, server)
self.apiroutine = RoutineContainer(self.scheduler)
self.client = ZooKeeperClient(self.apiroutine, self.serverlist)
self.connections.append(self.client)
self.apiroutine.main = self.main
self.routines.append(self.apiroutine)
def testSelfConnectionUnixDgram(self):
if not hasattr(socket, 'AF_UNIX'):
print('Skip UNIX socket test because not supported')
return
try:
os.remove('/var/run/unixsocktestudp1.sock')
except Exception:
pass
try:
os.remove('/var/run/unixsocktestudp2.sock')
except Exception:
pass
c1 = Client('dunix:/var/run/unixsocktestudp2.sock', self.protocolClient, self.scheduler, bindaddress = ((socket.AF_UNIX, '/var/run/unixsocktestudp1.sock'),))
c2 = Client('pdunix:/var/run/unixsocktestudp2.sock', self.protocolServer, self.scheduler)
r = RoutineContainer(self.scheduler, True)
ret = bytearray()
def mainA():
m = TestDataEvent.createMatcher()
while True:
yield (m,)
if r.event.connection is c2:
ret.extend(b'A')
else:
ret.extend(b'B')
r.main = mainA
r.start()
def waitAndStart(c):
for m in r.waitWithTimeout(0.5):
yield m
c.start()
r.subroutine(waitAndStart(c1))
c2.start()
self.scheduler.main()
self.assertEqual(ret, b'ABABABABABABABABABAB')
def __init__(self, server):
Module.__init__(self, server)
self.apiroutine = RoutineContainer(self.scheduler)
self.apiroutine.main = self._manage_conns
self.routines.append(self.apiroutine)
self.managed_conns = {}
self.managed_systemids = {}
self.managed_bridges = {}
self.managed_routines = []
self.endpoint_conns = {}
self.createAPI(api(self.getconnection, self.apiroutine),
api(self.waitconnection, self.apiroutine),
api(self.getdatapathids, self.apiroutine),
api(self.getalldatapathids, self.apiroutine),
api(self.getallconnections, self.apiroutine),
api(self.getbridges, self.apiroutine),
api(self.getbridge, self.apiroutine),
api(self.getbridgebyuuid, self.apiroutine),
api(self.waitbridge, self.apiroutine),
api(self.waitbridgebyuuid, self.apiroutine),
api(self.getsystemids, self.apiroutine),
api(self.getallsystemids, self.apiroutine),
api(self.getconnectionbysystemid, self.apiroutine),
api(self.waitconnectionbysystemid, self.apiroutine),
api(self.getconnectionsbyendpoint, self.apiroutine),
api(self.getconnectionsbyendpointname, self.apiroutine),
api(self.getendpoints, self.apiroutine),
api(self.getallendpoints, self.apiroutine),
api(self.getallbridges, self.apiroutine),
api(self.getbridgeinfo, self.apiroutine),
api(self.waitbridgeinfo, self.apiroutine))
self._synchronized = False
def testBeginlock(self):
rc = RoutineContainer(self.server.scheduler)
obj = [0]
def routineLock(key):
l = Lock(key, rc.scheduler)
locked = l.beginlock(rc)
if not locked:
for m in rc.waitWithTimeout(1.0):
yield m
locked = l.trylock()
if not locked:
raise ValueError('Not locked')
t = obj[0]
for m in rc.waitWithTimeout(0.5):
yield m
obj[0] = t + 1
l.unlock()
for m in rc.doEvents():
yield m
for m in l.lock(rc):
yield m
t = obj[0]
for m in rc.waitWithTimeout(1.0):
yield m
obj[0] = t + 1
l.unlock()
rc.subroutine(routineLock('testobj'))
rc.subroutine(routineLock('testobj'))
self.server.serve()
self.assertEqual(obj[0], 4)
def testBeginlock2(self):
rc = RoutineContainer(self.server.scheduler)
obj = [0]
async def routineLock(key):
l = Lock(key, rc.scheduler)
locked = l.beginlock(rc)
if not locked:
await rc.wait_with_timeout(0.2)
await l.lock(rc)
t = obj[0]
await rc.do_events()
obj[0] = t + 1
l.unlock()
await rc.do_events()
await l.lock(rc)
t = obj[0]
if t != 2:
obj[0] = t - 1
l.unlock()
rc.subroutine(routineLock('testobj'))
rc.subroutine(routineLock('testobj'))
self.server.serve()
self.assertEqual(obj[0], 2)
def __init__(self, server):
FlowBase.__init__(self, server)
self.apiroutine = RoutineContainer(self.scheduler)
self.apiroutine.main = self._main
self.routines.append(self.apiroutine)
self._flowupdaters = {}
self._extra_arps = {}
def __init__(self, server):
'''
Constructor
'''
Module.__init__(self, server)
self._ce_matcher = ConsoleEvent.createMatcher()
self.apiroutine = RoutineContainer(self.scheduler)
self.apiroutine.main = self._service_routine
self._restore_console_event = threading.Event()
@generator_to_async(True, False)
def proxy(event, matcher):
while True:
events = self.sendEventQueue.get()
if events is None:
break
yield events
@async_to_async(True, False)
@async_processor
def processor(event, matcher, queueout):
if event.type == 'initproxy':
proxy(event, matcher, queueout)
self.connector = Connector(processor, (self._ce_matcher, ),
self.scheduler, False)
self.routines.append(self.apiroutine)
self.routines.append(self.connector)
def testBlock(self):
scheduler = Scheduler()
scheduler.queue.addSubQueue(10, RoutineControlEvent.createMatcher())
scheduler.queue.addSubQueue(1, TestConsumerEvent.createMatcher(),
'consumer', 5, 5)
rA = RoutineContainer(scheduler)
output = bytearray()
def mainA():
rA.subroutine(mainB(), daemon=True)
for i in range(0, 10):
for ms in rA.waitForSend(TestConsumerEvent(rA.mainroutine)):
yield ms
output.extend(b'A')
def mainB():
for m in rA.doEvents():
yield m
matcher = TestConsumerEvent.createMatcher(producer=rA.mainroutine)
while True:
yield (matcher, )
rA.event.canignore = True
output.extend(b'B')
def mainC():
for m in rA.doEvents():
yield m
output.extend(b'C')
rA.main = mainA
rA.start()
rA.subroutine(mainC())
scheduler.main()
self.assertEqual(output, b'AAAAACBABABABABABBBBB')
def __init__(self, server):
super(NetworkNativeDriver, self).__init__(server)
self.app_routine = RoutineContainer(self.scheduler)
self.app_routine.main = self._main
self.routines.append(self.app_routine)
self.createAPI(
publicapi(self.createphysicalnetworks,
criteria=lambda networks, type: type == 'native'),
publicapi(self.updatephysicalnetworks,
criteria=lambda type, networks: type == 'native'),
publicapi(self.deletephysicalnetworks,
criteria=lambda type, networks: type == 'native'),
publicapi(self.createphysicalports,
criteria=lambda type, ports: type == 'native'),
publicapi(
self.updatephysicalports,
criteria=lambda phynettype, ports: phynettype == 'native'),
publicapi(
self.deletephysicalports,
criteria=lambda phynettype, ports: phynettype == 'native'),
publicapi(
self.createlogicalnetworks,
criteria=lambda phynettype, networks: phynettype == 'native'),
publicapi(
self.updatelogicalnetworks,
criteria=lambda phynettype, networks: phynettype == 'native'),
publicapi(
self.deletelogicalnetworks,
criteria=lambda phynettype, networks: phynettype == "native"),
#used in IOprocessing module
publicapi(self.createioflowparts,
criteria=lambda connection, logicalnetwork, physicalport,
logicalnetworkid, physicalportid: logicalnetwork.
physicalnetwork.type == "native"))
def testLoopConsumer(self):
scheduler = Scheduler()
scheduler.queue.addSubQueue(10, RoutineControlEvent.createMatcher())
scheduler.queue.addSubQueue(1, TestConsumerEvent.createMatcher(),
'consumer', 5, 5)
rA = RoutineContainer(scheduler)
output = bytearray()
def mainA():
rA.subroutine(mainB(), True, 'mainB', True)
matcher = TestConsumerEvent.createMatcher(rA.mainB)
for i in range(0, 10):
for ms in rA.waitForSend(TestConsumerEvent(rA.mainroutine)):
yield ms
output.extend(b'A')
yield (matcher, )
def mainB():
matcher = TestConsumerEvent.createMatcher(producer=rA.mainroutine)
while True:
yield (matcher, )
rA.event.canignore = True
output.extend(b'B')
for ms in rA.waitForSend(
TestConsumerEvent(rA.mainB, canignore=True)):
yield ms
rA.main = mainA
rA.start()
scheduler.main()
self.assertEqual(output, b'ABABABABABABABABABAB')
def __init__(self, server):
Module.__init__(self, server)
self.apiroutine = RoutineContainer(self.scheduler)
self.apiroutine.main = self._manage_conns
self.routines.append(self.apiroutine)
self.managed_conns = {}
self.endpoint_conns = {}
self.table_modules = set()
self._acquiring = False
self._acquire_updated = False
self._lastacquire = None
self._synchronized = False
self.createAPI(api(self.getconnections, self.apiroutine),
api(self.getconnection, self.apiroutine),
api(self.waitconnection, self.apiroutine),
api(self.getdatapathids, self.apiroutine),
api(self.getalldatapathids, self.apiroutine),
api(self.getallconnections, self.apiroutine),
api(self.getconnectionsbyendpoint, self.apiroutine),
api(self.getconnectionsbyendpointname, self.apiroutine),
api(self.getendpoints, self.apiroutine),
api(self.getallendpoints, self.apiroutine),
api(self.acquiretable, self.apiroutine),
api(self.unacquiretable, self.apiroutine),
api(self.lastacquiredtables))
def __init__(self, server):
super(NetworkVxlanDriver, self).__init__(server)
self.app_routine = RoutineContainer(self.scheduler)
self.app_routine.main = self._main
self.routines.append(self.app_routine)
self.createAPI(
publicapi(self.createphysicalnetworks,
criteria=lambda networks, type: type == 'vxlan'),
publicapi(self.updatephysicalnetworks,
criteria=lambda type, networks: type == 'vxlan'),
publicapi(self.deletephysicalnetworks,
criteria=lambda type, networks: type == 'vxlan'),
publicapi(self.createphysicalports,
criteria=lambda type, ports: type == 'vxlan'),
publicapi(
self.updatephysicalports,
criteria=lambda phynettype, ports: phynettype == 'vxlan'),
publicapi(
self.deletephysicalports,
criteria=lambda phynettype, ports: phynettype == 'vxlan'),
publicapi(
self.createlogicalnetworks,
criteria=lambda phynettype, networks: phynettype == 'vxlan'),
publicapi(
self.updatelogicalnetworks,
criteria=lambda phynettype, networks: phynettype == 'vxlan'),
publicapi(
self.deletelogicalnetworks,
criteria=lambda phynettype, networks: phynettype == "vxlan"))
def testCAVerify3(self):
c1 = Client('ssl://localhost:199', self.protocolClient, self.scheduler, None, None, 'testcerts/root.crt')
c2 = Client('pssl://localhost:199', self.protocolServer, self.scheduler, 'testcerts/server.key','testcerts/server.crt','testcerts/root.crt')
r = RoutineContainer(self.scheduler, True)
ret = bytearray()
def mainA():
m = TestDataEvent.createMatcher()
while True:
yield (m,)
if r.event.connection is c2:
ret.extend(b'A')
else:
ret.extend(b'B')
self.notconnected = False
def notConnected(connection):
if connection is c1:
self.notconnected = True
if False:
yield
self.protocolClient.notconnected = notConnected
r.main = mainA
r.start()
def waitAndStart(c):
for m in r.waitWithTimeout(0.5):
yield m
c.start()
r.subroutine(waitAndStart(c1))
c2.start()
self.scheduler.main()
self.assertTrue(self.notconnected)
self.assertEqual(ret, b'')
def testBlock(self):
scheduler = Scheduler()
scheduler.queue.addSubQueue(10, RoutineControlEvent.createMatcher())
scheduler.queue.addSubQueue(1, TestConsumerEvent.createMatcher(), 'consumer', 5, 5)
rA = RoutineContainer(scheduler)
output = bytearray()
async def mainA():
rA.subroutine(mainB(), daemon = True)
for _ in range(0,10):
await rA.wait_for_send(TestConsumerEvent(rA.mainroutine))
output.extend(b'A')
async def mainB():
await rA.do_events()
matcher = TestConsumerEvent.createMatcher(producer=rA.mainroutine)
while True:
ev = await matcher
ev.canignore = True
output.extend(b'B')
async def mainC():
await rA.do_events()
output.extend(b'C')
rA.main = mainA
rA.start()
rA.subroutine(mainC())
scheduler.main()
self.assertEqual(output, b'AAAAACBABABABABABBBBB')
def __init__(self, server):
FlowBase.__init__(self, server)
self.apiroutine = RoutineContainer(self.scheduler)
self.apiroutine.main = self._main
self.routines.append(self.apiroutine)
self._flowupdaters = {}
self._extra_arps = {}
self.createAPI(api(self.createproxyarp), api(self.removeproxyarp))
def __init__(self, server):
Module.__init__(self, server)
self.protocol = ZooKeeper()
self.client = Client(self.url, self.protocol, self.scheduler)
self.connections.append(self.client)
self.apiroutine = RoutineContainer(self.scheduler)
self.apiroutine.main = self.main
self.routines.append(self.apiroutine)
def __init__(self, server):
Module.__init__(self, server)
taskpool = TaskPool(self.scheduler)
self.taskpool = taskpool
self.routines.append(self.taskpool)
self.routines.append(NetworkPlugin(self))
self.apiroutine = RoutineContainer(self.scheduler)
self._reqid = 0
self.createAPI(api(self.getdockerinfo, self.apiroutine))
async def destroy(self, container=None):
"""
Destroy the created subqueue to change the behavior back to Lock
"""
if container is None:
container = RoutineContainer(self.scheduler)
if self.queue is not None:
await container.syscall_noreturn(
syscall_removequeue(self.scheduler.queue, self.queue))
self.queue = None
def __init__(self, server):
'''
Constructor
'''
Module.__init__(self, server)
self.apiroutine = RoutineContainer(self.scheduler)
self.createAPI(api(self.start, self.apiroutine),
api(self.create, self.apiroutine),
api(self.get, self.apiroutine),
api(self.destroy, self.apiroutine))
def __init__(self, server):
Module.__init__(self, server)
self.apiroutine = RoutineContainer(self.scheduler)
def _main():
try:
for m in self.run(*self.args, **self.kwargs):
yield m
finally:
self.scheduler.quit()
self.apiroutine.main = _main
self.routines.append(self.apiroutine)
def __init__(self, server, protocolclass):
Module.__init__(self, server)
self._protocolclass = protocolclass
self.apiroutine = RoutineContainer(self.scheduler)
self.managed_connections = set()
self._createServers(self, '')
self.createAPI(api(self.getservers),
api(self.stoplisten, self.apiroutine),
api(self.startlisten, self.apiroutine),
api(self.updateconfig, self.apiroutine),
api(self.getconnections))
def __init__(self, server):
Module.__init__(self, server)
self.apiroutine = RoutineContainer(self.scheduler)
async def _main():
try:
return await self.run(*self.args, **self.kwargs)
finally:
self.scheduler.quit()
self.apiroutine.main = _main
self.routines.append(self.apiroutine)
def __init__(self, server):
'''
Constructor
'''
Module.__init__(self, server)
self.timeoutroutine = RoutineContainer(self.scheduler)
self.timeoutroutine.main = self._timeout
self.db = {}
self.routines.append(self.timeoutroutine)
self.createAPI(api(self.get), api(self.set), api(self.delete),
api(self.mget), api(self.mgetwithcache), api(self.mset),
api(self.update), api(self.mupdate),
api(self.updateall), api(self.updateallwithtime))
def __init__(self, server):
Module.__init__(self, server)
self.apiroutine = RoutineContainer(self.scheduler)
self.apiroutine.main = self._manage_ports
self.routines.append(self.apiroutine)
self.managed_ports = {}
self.createAPI(api(self.getports, self.apiroutine),
api(self.getallports, self.apiroutine),
api(self.getportbyno, self.apiroutine),
api(self.waitportbyno, self.apiroutine),
api(self.getportbyname, self.apiroutine),
api(self.waitportbyname, self.apiroutine),
api(self.resync, self.apiroutine))
self._synchronized = False
