Пример #1
0
 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'))
Пример #2
0
 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'))
Пример #3
0
 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')))
Пример #4
0
 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)
Пример #5
0
 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)
Пример #6
0
 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'))
Пример #7
0
 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:]))
Пример #8
0
 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]))
Пример #9
0
 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)
Пример #10
0
 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)
Пример #11
0
 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
Пример #12
0
 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()
Пример #13
0
 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()
Пример #14
0
 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
Пример #15
0
 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)
Пример #16
0
 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)
Пример #17
0
 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()
Пример #18
0
 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]]])
Пример #19
0
 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]])
Пример #20
0
 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)
Пример #21
0
 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)
Пример #22
0
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()
Пример #23
0
    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'))))
Пример #24
0
 def eq(c):
     return self.assertEqual(c.value, b(5 * string.ascii_letters[i]))
Пример #25
0
 def handle_connect(self):
     self.transport.sendall(b("Foo\n"))
Пример #26
0
 def produce(value):
     return asynchia.ee.StringInput(b(''))
Пример #27
0
 def produce(self, value):
     result = asynchia.ee.StringInput(b(""))
     for expr, elem in zip(self.exprs, value):
         result += expr.produce(elem)
     return result
Пример #28
0
 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(''))
Пример #29
0
 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))
Пример #30
0
 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)