def setUp(self):
#self.scheduler
logging.basicConfig()
self.scheduler = Scheduler(DefaultPolling())
#self.scheduler.debugging = True
#self.scheduler.logger.setLevel('DEBUG')
#Client.logger.setLevel('DEBUG')
import tests
import os.path
rootpath, _ = os.path.split(tests.__path__[0])
if rootpath:
os.chdir(rootpath)
self.scheduler.queue.addSubQueue(3, PollEvent.createMatcher(category=PollEvent.WRITE_READY), 'write', None, None, CBQueue.AutoClassQueue.initHelper('fileno'))
self.scheduler.queue.addSubQueue(1, PollEvent.createMatcher(category=PollEvent.READ_READY), 'read', None, None, CBQueue.AutoClassQueue.initHelper('fileno'))
self.scheduler.queue.addSubQueue(5, PollEvent.createMatcher(category=PollEvent.ERROR), 'error')
self.scheduler.queue.addSubQueue(2, ConnectionControlEvent.createMatcher(), 'control')
self.scheduler.queue.addSubQueue(4, ConnectionWriteEvent.createMatcher(), 'connectionwrite', 40, 40, CBQueue.AutoClassQueue.initHelper('connection'))
self.scheduler.queue.addSubQueue(10, RoutineControlEvent.createMatcher(), 'routine')
self.scheduler.queue.addSubQueue(9, TimerEvent.createMatcher(), 'timer')
self.scheduler.queue.addSubQueue(8, ResolveResponseEvent.createMatcher(), 'resolve')
self.scheduler.queue.addSubQueue(8, ResolveRequestEvent.createMatcher(), 'resolvereq')
self.scheduler.queue.addSubQueue(20, SystemControlEvent.createMatcher(), 'sysctl')
self.scheduler.queue.addSubQueue(0, SystemControlLowPriorityEvent.createMatcher(), 'sysctllow')
#Client.logger.setLevel('DEBUG')
#TcpServer.logger.setLevel('DEBUG')
self.protocolServer = TestProtocol(True)
self.protocolClient = TestProtocol(False)
self.resolver = Resolver(scheduler=self.scheduler)
self.resolver.start()
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 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 _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 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 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 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 setUp(self):
#self.scheduler
logging.basicConfig()
self.scheduler = Scheduler(DefaultPolling())
#self.scheduler.debugging = True
#self.scheduler.logger.setLevel('DEBUG')
#Client.logger.setLevel('DEBUG')
import tests
import os.path
rootpath, _ = os.path.split(tests.__path__[0])
if rootpath:
os.chdir(rootpath)
self.scheduler.queue.addSubQueue(3, PollEvent.createMatcher(category=PollEvent.WRITE_READY), 'write', None, None, CBQueue.AutoClassQueue.initHelper('fileno'))
self.scheduler.queue.addSubQueue(1, PollEvent.createMatcher(category=PollEvent.READ_READY), 'read', None, None, CBQueue.AutoClassQueue.initHelper('fileno'))
self.scheduler.queue.addSubQueue(5, PollEvent.createMatcher(category=PollEvent.ERROR), 'error')
self.scheduler.queue.addSubQueue(2, ConnectionControlEvent.createMatcher(), 'control')
self.scheduler.queue.addSubQueue(4, ConnectionWriteEvent.createMatcher(), 'connectionwrite', 40, 40, CBQueue.AutoClassQueue.initHelper('connection'))
self.scheduler.queue.addSubQueue(10, RoutineControlEvent.createMatcher(), 'routine')
self.scheduler.queue.addSubQueue(9, TimerEvent.createMatcher(), 'timer')
self.scheduler.queue.addSubQueue(8, ResolveResponseEvent.createMatcher(), 'resolve')
self.scheduler.queue.addSubQueue(8, ResolveRequestEvent.createMatcher(), 'resolvereq')
self.scheduler.queue.addSubQueue(20, SystemControlEvent.createMatcher(), 'sysctl')
self.scheduler.queue.addSubQueue(0, SystemControlLowPriorityEvent.createMatcher(), 'sysctllow')
#Client.logger.setLevel('DEBUG')
#TcpServer.logger.setLevel('DEBUG')
self.protocolServer = TestProtocol(True)
self.protocolClient = TestProtocol(False)
self.resolver = Resolver(scheduler=self.scheduler)
self.resolver.start()
def testTimer(self):
scheduler = Scheduler()
rA = RoutineContainer(scheduler)
output = bytearray()
async def wait(timeout, append):
await rA.wait_with_timeout(timeout)
output.extend(append)
rA.subroutine(wait(0.1, b'B'))
rA.subroutine(wait(0.5, b'D'))
rA.subroutine(wait(0, b'A'))
rA.subroutine(wait(0.2, b'C'))
curr_time = time()
scheduler.main()
end_time = time()
self.assertEqual(output, b'ABCD')
self.assertTrue(0.4 < end_time - curr_time < 0.6)
def testTimer(self):
scheduler = Scheduler()
rA = RoutineContainer(scheduler)
output = bytearray()
def wait(timeout, append):
for m in rA.waitWithTimeout(timeout):
yield m
output.extend(append)
rA.subroutine(wait(0.1, b'B'))
rA.subroutine(wait(0.5, b'D'))
rA.subroutine(wait(0, b'A'))
rA.subroutine(wait(0.2, b'C'))
curr_time = time()
scheduler.main()
end_time = time()
self.assertEqual(output, b'ABCD')
self.assertTrue(0.4 < end_time - curr_time < 0.6)
def testWaitForAll(self):
scheduler = Scheduler()
rA = RoutineContainer(scheduler)
async def sender(num):
await rA.wait_for_send(TestEvent(num))
result = []
async def test():
try:
for i in range(10):
rA.subroutine(sender(i), False)
matchers = [TestEvent.createMatcher(i) for i in range(10)]
_, eventdict = await rA.wait_for_all(*matchers)
for m in matchers:
self.assertIn(m, eventdict)
self.assertTrue(m.isMatch(eventdict[m]))
except Exception as e:
result.append(e)
raise
else:
result.append(False)
rA.main = test
rA.start()
scheduler.main()
self.assertIs(result[0], False)
class TestConnection(unittest.TestCase):
def setUp(self):
#self.scheduler
logging.basicConfig()
self.scheduler = Scheduler(DefaultPolling())
#self.scheduler.debugging = True
#self.scheduler.logger.setLevel('DEBUG')
#Client.logger.setLevel('DEBUG')
import tests
import os.path
rootpath, _ = os.path.split(tests.__path__[0])
if rootpath:
os.chdir(rootpath)
self.scheduler.queue.addSubQueue(3, PollEvent.createMatcher(category=PollEvent.WRITE_READY), 'write', None, None, CBQueue.AutoClassQueue.initHelper('fileno'))
self.scheduler.queue.addSubQueue(1, PollEvent.createMatcher(category=PollEvent.READ_READY), 'read', None, None, CBQueue.AutoClassQueue.initHelper('fileno'))
self.scheduler.queue.addSubQueue(5, PollEvent.createMatcher(category=PollEvent.ERROR), 'error')
self.scheduler.queue.addSubQueue(2, ConnectionControlEvent.createMatcher(), 'control')
self.scheduler.queue.addSubQueue(4, ConnectionWriteEvent.createMatcher(), 'connectionwrite', 40, 40, CBQueue.AutoClassQueue.initHelper('connection'))
self.scheduler.queue.addSubQueue(10, RoutineControlEvent.createMatcher(), 'routine')
self.scheduler.queue.addSubQueue(9, TimerEvent.createMatcher(), 'timer')
self.scheduler.queue.addSubQueue(8, ResolveResponseEvent.createMatcher(), 'resolve')
self.scheduler.queue.addSubQueue(8, ResolveRequestEvent.createMatcher(), 'resolvereq')
self.scheduler.queue.addSubQueue(20, SystemControlEvent.createMatcher(), 'sysctl')
self.scheduler.queue.addSubQueue(0, SystemControlLowPriorityEvent.createMatcher(), 'sysctllow')
#Client.logger.setLevel('DEBUG')
#TcpServer.logger.setLevel('DEBUG')
self.protocolServer = TestProtocol(True)
self.protocolClient = TestProtocol(False)
self.resolver = Resolver(scheduler=self.scheduler)
self.resolver.start()
def tearDown(self):
pass
def testSelfConnection(self):
c1 = Client('tcp://localhost:199', self.protocolClient, self.scheduler)
c2 = Client('ptcp://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():
for m in r.waitWithTimeout(0.5):
yield m
c1.start()
r.subroutine(waitAndStart())
c2.start()
self.scheduler.main()
self.assertEqual(ret, b'ABABABABABABABABABAB')
def testServerClient(self):
c1 = Client('tcp://localhost:199', self.protocolClient, self.scheduler)
s1 = TcpServer('ltcp://localhost:199', self.protocolServer, self.scheduler)
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():
for m in r.waitWithTimeout(0.5):
yield m
c1.start()
r.subroutine(waitAndStart())
self.scheduler.main()
self.assertEqual(ret, b'ABABABABABABABABABAB')
def testMultipleClients(self):
c1 = Client('tcp://localhost:199', self.protocolClient, self.scheduler)
c2 = Client('tcp://localhost:199', self.protocolClient, self.scheduler)
s1 = TcpServer('ltcp://localhost:199', self.protocolServer, self.scheduler)
r = RoutineContainer(self.scheduler, True)
counter = {c1:0, c2:0}
ret = bytearray()
def mainA():
m = TestDataEvent.createMatcher()
c1c = False
c2c = False
shutdown = False
while True:
yield (m,)
counter[r.event.connection] = counter.get(r.event.connection, 0) + 1
if r.event.connection is c1:
ret.extend(b'A')
c1c = True
elif r.event.connection is c2:
ret.extend(b'B')
c2c = True
if c1c and c2c and not shutdown:
for m in s1.shutdown():
yield m
shutdown = 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))
r.subroutine(waitAndStart(c2))
self.scheduler.main()
print(ret)
self.assertEqual(counter[c1], 10)
self.assertEqual(counter[c2], 10)
def testSelfConnectionSsl(self):
c1 = Client('ssl://localhost:199', self.protocolClient, self.scheduler, 'testcerts/client.key','testcerts/client.crt','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')
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 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 testCAVerify(self):
c1 = Client('ssl://localhost:199', self.protocolClient, self.scheduler, 'testcerts/selfsigned.key','testcerts/selfsigned.crt','testcerts/selfsigned.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 testCAVerify2(self):
c1 = Client('ssl://localhost:199', self.protocolClient, self.scheduler, 'testcerts/selfsigned.key','testcerts/selfsigned.crt',None)
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 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 testSelfConnectionSslWithoutClientCertificate(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',None)
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 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 testSelfConnectionUnix(self):
if not hasattr(socket, 'AF_UNIX'):
print('Skip UNIX socket test because not supported')
return
try:
os.remove('/var/run/unixsocktest.sock')
except Exception:
pass
c1 = Client('unix:/var/run/unixsocktest.sock', self.protocolClient, self.scheduler)
c2 = Client('punix:/var/run/unixsocktest.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 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')
class TestConnection(unittest.TestCase):
def setUp(self):
#self.scheduler
logging.basicConfig()
self.scheduler = Scheduler(DefaultPolling())
#self.scheduler.debugging = True
#self.scheduler.logger.setLevel('DEBUG')
#Client.logger.setLevel('DEBUG')
import tests
import os.path
rootpath, _ = os.path.split(tests.__path__[0])
if rootpath:
os.chdir(rootpath)
self.scheduler.queue.addSubQueue(3, PollEvent.createMatcher(category=PollEvent.WRITE_READY), 'write', None, None, CBQueue.AutoClassQueue.initHelper('fileno'))
self.scheduler.queue.addSubQueue(1, PollEvent.createMatcher(category=PollEvent.READ_READY), 'read', None, None, CBQueue.AutoClassQueue.initHelper('fileno'))
self.scheduler.queue.addSubQueue(5, PollEvent.createMatcher(category=PollEvent.ERROR), 'error')
self.scheduler.queue.addSubQueue(2, ConnectionControlEvent.createMatcher(), 'control')
self.scheduler.queue.addSubQueue(4, ConnectionWriteEvent.createMatcher(), 'connectionwrite', 40, 40, CBQueue.AutoClassQueue.initHelper('connection'))
self.scheduler.queue.addSubQueue(10, RoutineControlEvent.createMatcher(), 'routine')
self.scheduler.queue.addSubQueue(9, TimerEvent.createMatcher(), 'timer')
self.scheduler.queue.addSubQueue(8, ResolveResponseEvent.createMatcher(), 'resolve')
self.scheduler.queue.addSubQueue(8, ResolveRequestEvent.createMatcher(), 'resolvereq')
self.scheduler.queue.addSubQueue(20, SystemControlEvent.createMatcher(), 'sysctl')
self.scheduler.queue.addSubQueue(0, SystemControlLowPriorityEvent.createMatcher(), 'sysctllow')
#Client.logger.setLevel('DEBUG')
#TcpServer.logger.setLevel('DEBUG')
self.protocolServer = TestProtocol(True)
self.protocolClient = TestProtocol(False)
self.resolver = Resolver(scheduler=self.scheduler)
self.resolver.start()
def tearDown(self):
pass
def testSelfConnection(self):
c1 = Client('tcp://localhost:199', self.protocolClient, self.scheduler)
c2 = Client('ptcp://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():
for m in r.waitWithTimeout(0.5):
yield m
c1.start()
r.subroutine(waitAndStart())
c2.start()
self.scheduler.main()
self.assertEqual(ret, b'ABABABABABABABABABAB')
def testServerClient(self):
c1 = Client('tcp://localhost:199', self.protocolClient, self.scheduler)
s1 = TcpServer('ltcp://localhost:199', self.protocolServer, self.scheduler)
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():
for m in r.waitWithTimeout(0.5):
yield m
c1.start()
r.subroutine(waitAndStart())
self.scheduler.main()
self.assertEqual(ret, b'ABABABABABABABABABAB')
def testMultipleClients(self):
c1 = Client('tcp://localhost:199', self.protocolClient, self.scheduler)
c2 = Client('tcp://localhost:199', self.protocolClient, self.scheduler)
s1 = TcpServer('ltcp://localhost:199', self.protocolServer, self.scheduler)
r = RoutineContainer(self.scheduler, True)
counter = {c1:0, c2:0}
ret = bytearray()
def mainA():
m = TestDataEvent.createMatcher()
c1c = False
c2c = False
shutdown = False
while True:
yield (m,)
counter[r.event.connection] = counter.get(r.event.connection, 0) + 1
if r.event.connection is c1:
ret.extend(b'A')
c1c = True
elif r.event.connection is c2:
ret.extend(b'B')
c2c = True
if c1c and c2c and not shutdown:
for m in s1.shutdown():
yield m
shutdown = 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))
r.subroutine(waitAndStart(c2))
self.scheduler.main()
print(ret)
self.assertEqual(counter[c1], 10)
self.assertEqual(counter[c2], 10)
def testSelfConnectionSsl(self):
c1 = Client('ssl://localhost:199', self.protocolClient, self.scheduler, 'testcerts/client.key','testcerts/client.crt','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')
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 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 testCAVerify(self):
c1 = Client('ssl://localhost:199', self.protocolClient, self.scheduler, 'testcerts/selfsigned.key','testcerts/selfsigned.crt','testcerts/selfsigned.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 testCAVerify2(self):
c1 = Client('ssl://localhost:199', self.protocolClient, self.scheduler, 'testcerts/selfsigned.key','testcerts/selfsigned.crt',None)
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 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 testSelfConnectionSslWithoutClientCertificate(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',None)
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 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 testSelfConnectionUnix(self):
if not hasattr(socket, 'AF_UNIX'):
print('Skip UNIX socket test because not supported')
return
try:
os.remove('/var/run/unixsocktest.sock')
except:
pass
c1 = Client('unix:/var/run/unixsocktest.sock', self.protocolClient, self.scheduler)
c2 = Client('punix:/var/run/unixsocktest.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 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:
pass
try:
os.remove('/var/run/unixsocktestudp2.sock')
except:
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')
