コード例 #1
0
ファイル: test_basic.py プロジェクト: BeeswaxIO/gipcrpc
        def _test_simple():
            n_levels = (1, 2, 5, 10)
            c_levels = (1, 5, 10, 50)
            q_sizes = (None, 1, 5, 10, 50)

            for n, c, q in itertools.product(n_levels, c_levels, q_sizes):
                with child_service(MyService, n_process=n, concurrency=c, queue_size=q) as client:
                    for i in xrange(n):
                        a = i * 2 + 7
                        b = i * 3 + 5
                        expected = a + b
                        result = client.call('sum', a, b)
                        eq_(result, expected)

                        expected_m = a * b
                        result_m = client.call('multiply', a, b)
                        eq_(result_m, expected_m)

                with child_service(MyService, concurrency=c, queue_size=q) as client:
                    future = client.call_async('sum', 3, 7)
                    value = future.get()
                    eq_(value, 10)

                cb_data = dict(value=None, called=False)
                with child_service(MyService, concurrency=c, queue_size=q) as client:
                    def _callback(value):
                        cb_data['value'] = value
                        cb_data['called'] = True

                    client.call_callback(_callback, 'sum', 1, 2)

                ok_(cb_data['called'])
                eq_(cb_data['value'], 3)
コード例 #2
0
ファイル: simple.py プロジェクト: BeeswaxIO/gipcrpc
def main():
    # 'concurrency' will control simultaneous processing gleenlet number on service
    # fork only 1 process for MyService
    with child_service(MyService, concurrency=10) as client:
        # async callback
        def _callback(value):
            print '_callback: value=%d' % value
        client.call_callback(_callback, 'sum', 1, 2)

        # blocking call
        print 'block call: value=%d' % client.call('sum', 2, 3)

        # future(gevent.event.AsyncResult object)
        future = client.call_async('sum', 10, 20)
        print 'future: value=%d' % future.get()  # will block until service side computation finishes
コード例 #3
0
ファイル: test_basic.py プロジェクト: BeeswaxIO/gipcrpc
        def _test_delay():
            n_levels = (1, 2, 3, 4, 5)
            c_levels = (5, 10, 50)  # concurrency=1 can't pass this test on p=1
            q_sizes = (None, 5, 10, 50)

            for p, c, q in itertools.product(n_levels, c_levels, q_sizes):
                called = []

                with child_service(DelayService, n_process=p, concurrency=c, queue_size=q) as client:
                    def _cb(value):
                        print value
                        called.append(value)

                    client.call_callback(_cb, 'delay', 500)  # returns 3rd
                    gevent.sleep()
                    client.call_callback(_cb, 'delay', 100)  # returns 1st
                    gevent.sleep()
                    client.call_callback(_cb, 'delay', 300)  # returns 2nd

                eq_(called, [100, 300, 500])
コード例 #4
0
ファイル: multi_proc.py プロジェクト: BeeswaxIO/gipcrpc
def main():
    t1 = time.time()
    n = 10000
    with child_service(MyService, n_process=8, concurrency=1) as client:

        for i in xrange(n):
            arg = str(i)
            def _cb(value, arg=None):
                global count
                count += 1
                # print '%s => %s count=%d' % (arg, value, count)
            _cb = functools.partial(_cb, arg=arg)  # preseve original arg to show debug msg
            client.call_callback(_cb, 'superhash', arg)

        def _waiter():
            global count
            while count < n:
                gevent.sleep(0.1)

        waiter = gevent.spawn(_waiter)
        waiter.join()
        t2 = time.time()
        print '%fsec' % (t2-t1)