def testSocketHandshake(self):
with Reactor() as reactor:
lhs, rhs = socketpair()
def peter(channel):
with channel:
message = yield
yield 'Hello ' + message[-4:]
def jack(channel):
with channel:
x = yield 'My name is Jack'
self.assertEquals(None, x)
self.response = yield
Gio(reactor, jack(SocketContext(lhs)))
Gio(reactor, peter(SocketContext(rhs)))
reactor.step().step().step().step()
self.assertEquals('Hello Jack', self.response)
def test():
done = []
def handler():
yield
yield 'a'
done.append(True)
try:
g = Gio(reactor(), handler())
self.fail('must not come here')
except AssertionError, e:
self.assertEquals('Gio: No context available.', str(e))
def testHowToCreateAHttpServer(self):
port = PortNumberGenerator.next()
# SERVER
class HttpServer:
def __init__(self, reactor, port):
ear = socket()
ear.bind(('0.0.0.0', port))
ear.listen(127)
ear.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
reactor.addReader(ear, self)
self._ear = ear
self._reactor = reactor
def __call__(self):
connection, address = self._ear.accept()
Gio(self._reactor,
self.handleConnection(SocketContext(connection)))
def handleConnection(self, connection):
with connection:
yield self.handleRequest()
def handleRequest(self):
msg = yield
yield 'HTTP/1.1 200 Ok\r\n\r\nGoodbye'
def stop(self):
self._reactor.removeReader(self._ear)
server = HttpServer(self.reactor, port)
#CLIENT
responses = []
def connection(host, port):
connection = socket()
connection.connect((host, port))
return SocketContext(connection)
def httpClient():
with connection('localhost', port):
yield 'GET %s HTTP/1.0\r\n\r\n' % '/'
response = yield
responses.append(response)
Gio(self.reactor, httpClient())
while not responses:
self.reactor.step()
self.assertEquals(['HTTP/1.1 200 Ok\r\n\r\nGoodbye'], responses)
server.stop()
def testLargeBuffers(self):
with stdout_replaced():
with Reactor() as reactor:
lhs, rhs = socketpair()
messages = []
messageSize = 1024 * 128
def peter(channel):
with channel:
while True:
messages.append((yield))
def jack(channel):
with channel:
yield 'X' * messageSize
Gio(reactor, jack(SocketContext(lhs)))
Gio(reactor, peter(SocketContext(rhs)))
while sum(len(message) for message in messages) < messageSize:
reactor.step()
self.assertTrue(
len(messages) >
1) # test is only sensible when multiple parts are sent
self.assertEquals(messageSize, len(''.join(messages)))
def XXXXXXXXXXXXXtestNeverExittedContextIsForcedToExitByGeneratorExitWhileReading(
self):
context = giopen(self.tempfile, 'rw')
def neverExit():
with context:
while True: # never exit context, unless with exception
yield
proc = neverExit()
g = Gio(self.reactor, proc)
self.reactor.step()
try:
proc.throw(GeneratorExit()) # force exit outside Gio()
self.fail('Must not come here')
except GeneratorExit:
pass
self.assertEquals([], g._contextstack)
def XXXtestGioAsContext(self):
# TS: Disabled: file-contexts don't work with epoll' Reactor since a file-fd is *always* readable and writable.
open(self.tempfile, 'w').write('read this!')
def myProcessor():
with giopen(self.tempfile, 'rw') as datastream:
self.assertTrue(isinstance(datastream, Context))
self.dataIn = yield
yield 'write this!'
Gio(self.reactor, myProcessor())
self.reactor.step()
self.assertEquals('read this!', self.dataIn[:19])
self.reactor.step()
self.assertEquals('read this!write this!',
open(self.tempfile).read()[:21])
self.assertEquals({}, self.reactor._readers)
self.assertEquals({}, self.reactor._writers)
def test():
done = []
def handler():
lhs, rhs = socketpair()
try:
with SocketContext(lhs): # quick hack, can block.
with Timer(0.01):
yield 'a'
yield 'b'
finally:
lhs.close()
rhs.close()
done.append(True)
g = Gio(reactor(), handler())
for _ in range(42):
yield
self.assertEquals([True], done)
self.assertEquals([], reactor()._timers)
self.assertEquals([], g._contextstack)
def testNeverExittedContextIsForcedToExitByGeneratorExitWhileWriting(self):
lhs, rhs = socketpair()
try:
context = SocketContext(lhs) # quick hack, can block.
def neverExit():
with context:
while True: # never exit context, unless with exception
yield 'ape'
proc = neverExit()
g = Gio(self.reactor, proc)
self.reactor.step()
try:
proc.throw(GeneratorExit()) # force exit outside Gio()
self.fail('Must not come here')
except StopIteration:
pass
self.assertEquals([], g._contextstack)
finally:
lhs.close()
rhs.close()
def XXXtestNesting(self):
# TS: Disabled: file-contexts don't work with epoll' Reactor since a file-fd is *always* readable and writable.
done = []
open(self.tempdir + '/1', 'w').write('1234')
open(self.tempdir + '/2', 'w').write('abcd')
def swapContents():
numbersStream = giopen(self.tempdir + '/1', 'rw')
lettersStream = giopen(self.tempdir + '/2', 'rw')
with numbersStream:
numbers = yield
with lettersStream:
letters = yield
yield numbers
yield letters
done.append(True)
Gio(self.reactor, swapContents())
while not done:
self.reactor.step()
self.assertEquals('1234abcd', open(self.tempdir + '/1').read())
self.assertEquals('abcd1234', open(self.tempdir + '/2').read())
def test():
done = []
def handler():
lhs, rhs = socketpair()
try:
with SocketContext(lhs): # quick hack, can block.
with Timer(0.01):
for i in xrange(999999):
yield 'a'
except TimeoutException:
done.append(False)
finally:
lhs.close
rhs.close()
yield
g = Gio(reactor(), handler())
while not done:
yield
self.assertEquals([False], done)
self.assertEquals([], reactor()._timers)
self.assertEquals([], g._contextstack)
def __call__(self):
connection, address = self._ear.accept()
Gio(self._reactor,
self.handleConnection(SocketContext(connection)))
def connect(self):
connection, address = self._ear.accept()
connection.setsockopt(SOL_TCP, TCP_CORK, 1)
Gio(self._reactor, self.processConnection(SocketContext(connection)))