sampsyo / bluelet Goto Github PK

import bluelet
import random

class TestProxy:
    _suspeneded = {}
    _messages = {}
    _continue_exec = True

    def init(self):
        print "Initializing"
        while TestProxy._continue_exec:
            print "Checking for messages"
            for k in TestProxy._messages.keys():
                if random.randint(0,100) < 50:
                    if k in TestProxy._suspeneded:
                        TestProxy._messages[k] = 0
                        print "Message sent {}".format(k)
                        yield bluelet.kill(TestProxy._suspeneded[k])
                        del TestProxy._suspeneded[k]
                        print "Killed {}".format(k)
            yield bluelet.sleep(1)
        print "Shutting down"

    def call_sync(self, num):
        # Setup
        TestProxy._messages[self] = None
        print "{} was passed".format(num)

        def inner_call_sync(self):
            while TestProxy._messages[self] is None:
                print "Sleeping {}".format(self)
                yield bluelet.sleep(600)

        # Create wait coroutine
        coro = inner_call_sync(self)
        # Store reference to wait coroutine
        TestProxy._suspeneded[self] = coro
        # Start and block on wait coroutine
        yield coro

        # Get message a cleanup
        print "Message Received {}".format(TestProxy._messages[self])
        message = TestProxy._messages.pop(self)
        yield bluelet.end(message)

    def call_timeout(self, num, timeout):
        # Setup
        TestProxy._messages[self] = None
        print "{} was passed".format(num)

        def inner_call_timeout(self, timeout):
            print "Sleeping {} for {}".format(self, timeout)
            yield bluelet.sleep(timeout)

        # Create wait coroutine
        coro = inner_call_timeout(self, timeout)
        # Store reference to wait coroutine
        TestProxy._suspeneded[self] = coro
        # Start and block on wait coroutine
        yield coro

        # Get message a cleanup
        print "Message Received {}".format(TestProxy._messages[self])
        message = TestProxy._messages.pop(self)
        yield bluelet.end(message)

    def call_async(self, num):
        # Setup
        TestProxy._messages[self] = None
        print "{} was passed".format(num)

        def inner_call_async(self):
            while TestProxy._messages[self] is None:
                print "Sleeping {}".format(self)
                yield bluelet.sleep(600)

        # Create wait coroutine
        coro = inner_call_async(self)
        # Store reference to wait coroutine
        TestProxy._suspeneded[self] = coro
        # Start wait coroutine
        yield bluelet.spawn(coro)

        def inner_finish(self, coro):
            print "Waiting on future"
            yield bluelet.join(coro)
            # Get message a cleanup
            print "Message Received {}".format(TestProxy._messages[self])
            message = TestProxy._messages.pop(self)
            yield bluelet.end(message)

        # Returning future
        yield bluelet.end(inner_finish(self, coro))


    def shutdown(self):
        TestProxy._continue_exec = False

def test(num):
    print "Number is {}".format(num)

    tp = TestProxy()

    ret = yield tp.call_sync(num)

    print "Returned {}".format(ret)

def test2(num):
    print "Number is {}".format(num)

    tp = TestProxy()

    ret = yield tp.call_timeout(num, 2)

    if ret is None:
        print "Call timed out"
    else:
        print "Returned {}".format(ret)

def test3(num):
    print "Number is {}".format(num)

    tp = TestProxy()

    fut = yield tp.call_async(num)

    yield bluelet.sleep(60)

    print "Async called"

    ret = yield fut

    print "Returned {}".format(ret)

def main():
    yield bluelet.spawn(TestProxy().init())
    #yield bluelet.spawn(test(42))
    #yield bluelet.spawn(test(43))
    #yield bluelet.spawn(test2(44))
    #yield bluelet.spawn(test2(45))
    yield bluelet.spawn(test3(46))
    yield bluelet.spawn(test3(47))
    yield bluelet.sleep(300)
    TestProxy().shutdown()

bluelet.run(main())