def end_interrupt(self, changeflags=False):
""" See SocketMap.end_interrupt. """
if not changeflags:
# Same as FragileSocketMap.end_interrupt.
self.controlsender.send(b('e'))
else:
self.controlsender.send(b('s'))
self.controlsender.recv(1)
self.controlsender.send(b('e'))
def test_inputadd(self):
m = asynchia.ee.MockHandler()
q = asynchia.ee.StringInput(b('a')) + asynchia.ee.StringInput(b('b'))
id1 = id(q)
q += asynchia.ee.StringInput(b('c'))
id2 = id(q)
self.assertEqual(id1, id2)
until_done(lambda: q.tick(m))
self.assertEqual(m.outbuf, b('abc'))
def test_LFLSE(self):
e = db.L() + db.B() + LFLSE(-1)
m = asynchia.ee.MockHandler(
inbuf=e.produce((5, 1, b('ABCDE'))) + b('FG')
)
a = e(None)
until_done(lambda: a.add_data(m, 120))
self.assertEqual(tuple(a.value), (5, 1, b('A')))
def test_collectoradd(self):
a = del_strcoll(5)
c = del_strcoll(6)
q = a + c
m = asynchia.ee.MockHandler(b('a') * 5 + b('b') * 6)
until_done(lambda: q.add_data(m, 2))
self.assertEqual(a.collector.value, b('a') * 5)
self.assertEqual(c.collector.value, b('b') * 6)
def test_factoryinput(self):
itr = (asynchia.ee.StringInput(b(5 * string.ascii_letters[i]))
for i in xrange(3))
c = asynchia.ee.FactoryInput(
asynchia.ee.FactoryInput.wrap_iterator(itr.next)
)
m = asynchia.ee.MockHandler()
until_done(lambda: c.tick(m))
self.assertEqual(m.outbuf, b('a') * 5 + b('b') * 5 + b('c') * 5)
self.assertEqual(c.tick(m)[0], True)
def test_named(self):
e = db.L()['size'] + db.B()['blub'] + FLSE(lookback('size'))['string']
a = e(None)
m = asynchia.ee.MockHandler(
inbuf=e.produce((5, 1, b('ABCDE'))) + b('FG')
)
until_done(lambda: a.add_data(m, 120))
self.assertEqual(tuple(a.value), (5, 1, b('ABCDE')))
self.assertEqual(m.inbuf, b('FG'))
def test_delimited(self):
c = asynchia.ee.DelimitedCollector(
asynchia.ee.StringCollector(), 5
)
m = asynchia.ee.MockHandler(inbuf=b(string.ascii_letters))
n = c.add_data(m, 10)
self.assertEqual(n[1], 5)
# As we are using a MockHandler, we can be sure the collector
# collected all 5 bytes it was supposed to.
self.assertEqual(c.add_data(m, 10)[0], True)
# The collector
self.assertEqual(c.collector.value, b(string.ascii_letters[:5]))
self.assertEqual(m.inbuf, b(string.ascii_letters[5:]))
def test_filecollector_notclosing(self):
c = asynchia.ee.FileCollector(
get_named_tempfile(delete=False),
False
)
m = asynchia.ee.MockHandler(inbuf=b(string.ascii_letters))
c.add_data(m, 10)
c.close()
c.value.seek(0)
r = b('')
while len(r) < 10:
r += c.value.read(10 - len(r))
self.assertEqual(r, b(string.ascii_letters[:10]))
def test_nested(self):
i = [2, b('AB'), [5, b('ABCDE')], [5, b('ABCDE')]]
a = db.B() + LFLSE(0)
c = db.B() + LFLSE(0) + a + a
d = c.produce(i)
p = c(None)
m = asynchia.ee.MockHandler(inbuf=d + b('FG'))
until_done(lambda: p.add_data(m, 120))
self.assertEqual(exhaust(iter(p.value)), i)
def test_factorycollector(self):
def make_eq(i):
def eq(c):
return self.assertEqual(c.value, b(5 * string.ascii_letters[i]))
return eq
itr = (asynchia.ee.DelimitedCollector(
asynchia.ee.StringCollector(make_eq(i)), 5) for i in xrange(3))
c = asynchia.ee.FactoryCollector(
asynchia.ee.FactoryCollector.wrap_iterator(itr.next)
)
m = asynchia.ee.MockHandler(
inbuf=b('a') * 5 + b('b') * 5 + b('c') * 5 + b('d'))
until_done(lambda: c.add_data(m, 5))
self.assertEqual(c.add_data(m, 1)[0], True)
def do_interrupt(self):
""" Call this in the socket-map when you have found out that there is
data to read on the controlreceiver. """
# Read the "s" that started the interrupt
recv = self.controlreceiver.recv(1)
if recv == b('s'):
# Send the "i" that signals the interrupt succeeded.
self.controlreceiver.send(b('i'))
# Read the "e" that will end the interrupt.
self.controlreceiver.recv(1)
elif recv == b('b'):
return
else:
raise ValueError
def test_fromfilename(self):
strings = [
b('a' + '\n') * i + b('b' + '\r\n') * j
for i in xrange(1, 20)
for j in xrange(1, 20)
]
for string in strings:
fd = get_named_tempfile(delete=True)
try:
fd.write(string)
fd.flush()
fd.seek(0)
c = asynchia.ee.FileInput.from_filename(fd.name, 'r')
self.assertEqual(len(c), len(string))
finally:
fd.close()
def close(self):
""" Signal the interrupt is finished to any thread that may be
waiting, as the program, waiting for the thread to finish,
would not be able to exit otherwise. """
if self.needresp:
self.controlreceiver.send(b('i'))
self.needresp = False
super(RobustSocketMap, self).close()
def start_interrupt(self, changeflags=False):
""" See SocketMap.start_interrupt. """
if not changeflags:
# Same as FragileSocketMap.start_interrupt.
self.controlsender.send(b('s'))
self.controlsender.recv(1)
else:
self.needresp = True
def test_filecollector_closing(self):
c = asynchia.ee.FileCollector(
get_named_tempfile(delete=False)
)
m = asynchia.ee.MockHandler(inbuf=b(string.ascii_letters))
c.add_data(m, 10)
c.close()
# I/O operation on closed file.
self.assertRaises(ValueError, c.value.read, 6)
def test_autoflush(self):
fd = get_named_tempfile(delete=True)
fc = asynchia.ee.FileCollector(fd, autoflush=True)
i = 0
m = asynchia.ee.MockHandler(b('a') * 20000000)
while m.inbuf:
d, n = fc.add_data(m, 8000000)
i += n
self.assertEqual(os.stat(fd.name).st_size, i)
def test_lenpredict(self):
strings = [b('a') * i for i in xrange(1, 20)]
for string in strings:
fd = get_named_tempfile(delete=True)
try:
fd.write(string)
fd.flush()
fd.seek(0)
c = asynchia.ee.FileInput(fd)
self.assertEqual(len(c), len(string))
finally:
fd.close()
def test_nested_mul_glob(self):
x = db.B()['foo'] + (lambda x: 2) * ((lambda x: x.glob('foo').value) * db.B())
c = x()
prod = x.produce((3, ((1, 2, 5), (4, 5, 6))))
self.assertEqual(
prod,
struct.pack('!BBBBBBB', 3, 1, 2, 5, 4, 5, 6)
)
m = asynchia.ee.MockHandler(prod + b('x'))
until_done(lambda: c.add_data(m, 10))
self.assertEqual(exhaust(c.value), [3, [[1, 2, 5], [4, 5, 6]]])
def test_mul2(self):
x = db.B() + db.B() * lookback(0)
c = x()
prod = x.produce((3, (1, 2, 5)))
self.assertEqual(
prod,
struct.pack('!BBBB', 3, 1, 2, 5)
)
m = asynchia.ee.MockHandler(prod + b('x'))
until_done(lambda: c.add_data(m, 10))
self.assertEqual(exhaust(c.value), [3, [1, 2, 5]])
def test_inputqueue(self):
m = asynchia.ee.MockHandler()
a = asynchia.ee.StringInput(b('a') * 5)
c = asynchia.ee.StringInput(b('b') * 5)
d = asynchia.ee.StringInput(b('c') * 5)
q = asynchia.ee.InputQueue([a, c, d])
until_done(lambda: q.tick(m))
self.assertEqual(m.outbuf, b('a') * 5 + b('b') * 5 + b('c') * 5)
def test_collectorqueue(self):
a = asynchia.ee.DelimitedCollector(
asynchia.ee.StringCollector(), 5
)
c = asynchia.ee.DelimitedCollector(
asynchia.ee.StringCollector(), 4
)
d = asynchia.ee.DelimitedCollector(
asynchia.ee.StringCollector(), 3
)
q = asynchia.ee.CollectorQueue([a, c, d])
m = asynchia.ee.MockHandler(inbuf=b('a') * 5 + b('b') * 4 + b('c') * 3)
until_done(lambda: q.add_data(m, 5))
self.assertEqual(a.collector.value, b('a') * 5)
self.assertEqual(c.collector.value, b('b') * 4)
self.assertEqual(d.collector.value, b('c') * 3)
class EchoAcceptor(asynchia.AcceptHandler):
def handle_accept(self, sock, addr):
collector = asynchia.ee.FileCollector(byte_std(sys.stdout), False, True)
asynchia.ee.Handler(
asynchia.SocketTransport(
self.transport.socket_map, sock
),
collector)
def handle_error(self):
raise
if __name__ == '__main__':
# This should show "Foo" in your console.
m = asynchia.maps.DefaultSocketMap()
a = EchoAcceptor(asynchia.SocketTransport(m))
a.transport.reuse_addr()
a.transport.bind(('127.0.0.1', 25000))
a.transport.listen(0)
c = asynchia.ee.Handler(asynchia.SocketTransport(m))
c.transport.connect(('127.0.0.1', 25000))
c.send_input(asynchia.ee.StringInput(b("Foo\n")))
try:
m.run()
finally:
m.close()
def test_and(self):
net16 = db.H() + LFLSE(-1)
net32 = db.L() + LFLSE(-1)
pair = net16 & net32
pair.produce(((5, b('hello')), (5, b('world'))))
def eq(c):
return self.assertEqual(c.value, b(5 * string.ascii_letters[i]))
def handle_connect(self):
self.transport.sendall(b("Foo\n"))
def produce(value):
return asynchia.ee.StringInput(b(''))
def produce(self, value):
result = asynchia.ee.StringInput(b(""))
for expr, elem in zip(self.exprs, value):
result += expr.produce(elem)
return result
def test_notclosing(self):
i = asynchia.ee.FileInput.from_filename(__file__, closing=False)
i.close()
# Verify file is not closed.
self.assertEqual(i.fd.read(0), b(''))
def test_stringinput(self):
m = asynchia.ee.MockHandler()
i = asynchia.ee.StringInput(b(string.ascii_letters))
i.tick(m)
self.assertEqual(m.outbuf, b(string.ascii_letters))
def test_close(self):
c = asynchia.ee.DelimitedCollector(asynchia.ee.StringCollector(), 5)
m = asynchia.ee.MockHandler(b('abcde'))
c.add_data(m, 10)
self.assertEqual(c.closed, True)
