Esempio n. 1
0
    def __init__(self, gui, sender_address, receiver_address):
        super(ChatMesssenger, self).__init__()
        self.gui = gui
        self.sender_address = sender_address
        self.receiver_address = receiver_address

        self.events = EventInjector()
        self.sender = None

        self.ready_to_send = False
        self.outgoing_queue = Queue()
Esempio n. 2
0
class ApplicationEventTest(Test):
    """Test application defined events and handlers."""

    class MyTestServer(TestServer):
        def __init__(self):
            super(ApplicationEventTest.MyTestServer, self).__init__()

    class MyHandler(Handler):
        def __init__(self, test):
            super(ApplicationEventTest.MyHandler, self).__init__()
            self._test = test

        def on_hello(self, event):
            # verify PROTON-1056
            self._test.hello_rcvd = str(event)

        def on_goodbye(self, event):
            self._test.goodbye_rcvd = str(event)

    def setUp(self):
        import os
        if not hasattr(os, 'pipe'):
          # KAG: seems like Jython doesn't have an os.pipe() method
          raise SkipTest()
        if os.name=="nt":
          # Correct implementation on Windows is complicated
          raise SkipTest("PROTON-1071")
        self.server = ApplicationEventTest.MyTestServer()
        self.server.reactor.handler.add(ApplicationEventTest.MyHandler(self))
        self.event_injector = EventInjector()
        self.hello_event = ApplicationEvent("hello")
        self.goodbye_event = ApplicationEvent("goodbye")
        self.server.reactor.selectable(self.event_injector)
        self.hello_rcvd = None
        self.goodbye_rcvd = None
        self.server.start()

    def tearDown(self):
        self.server.stop()

    def _wait_for(self, predicate, timeout=10.0):
        deadline = time.time() + timeout
        while time.time() < deadline:
            if predicate():
                break
            time.sleep(0.1)
        assert predicate()

    def test_application_events(self):
        self.event_injector.trigger(self.hello_event)
        self._wait_for(lambda: self.hello_rcvd is not None)
        self.event_injector.trigger(self.goodbye_event)
        self._wait_for(lambda: self.goodbye_rcvd is not None)
Esempio n. 3
0
class ApplicationEventTest(Test):
    """Test application defined events and handlers."""

    class MyTestServer(TestServer):
        def __init__(self):
            super(ApplicationEventTest.MyTestServer, self).__init__()

    class MyHandler(Handler):
        def __init__(self, test):
            super(ApplicationEventTest.MyHandler, self).__init__()
            self._test = test

        def on_hello(self, event):
            # verify PROTON-1056
            self._test.hello_rcvd = str(event)

        def on_goodbye(self, event):
            self._test.goodbye_rcvd = str(event)

    def setUp(self):
        import os
        if not hasattr(os, 'pipe'):
          # KAG: seems like Jython doesn't have an os.pipe() method
          raise SkipTest()
        if os.name=="nt":
          # Correct implementation on Windows is complicated
          raise SkipTest("PROTON-1071")
        self.server = ApplicationEventTest.MyTestServer()
        self.server.reactor.handler.add(ApplicationEventTest.MyHandler(self))
        self.event_injector = EventInjector()
        self.hello_event = ApplicationEvent("hello")
        self.goodbye_event = ApplicationEvent("goodbye")
        self.server.reactor.selectable(self.event_injector)
        self.hello_rcvd = None
        self.goodbye_rcvd = None
        self.server.start()

    def tearDown(self):
        self.server.stop()

    def _wait_for(self, predicate, timeout=10.0):
        deadline = time.time() + timeout
        while time.time() < deadline:
            if predicate():
                break
            time.sleep(0.1)
        assert predicate()

    def test_application_events(self):
        self.event_injector.trigger(self.hello_event)
        self._wait_for(lambda: self.hello_rcvd is not None)
        self.event_injector.trigger(self.goodbye_event)
        self._wait_for(lambda: self.goodbye_rcvd is not None)
Esempio n. 4
0
class ChatMesssenger(MessagingHandler):
    def __init__(self, gui, sender_address, receiver_address):
        super(ChatMesssenger, self).__init__()
        self.gui = gui
        self.sender_address = sender_address
        self.receiver_address = receiver_address

        self.events = EventInjector()
        self.sender = None

        self.ready_to_send = False
        self.outgoing_queue = Queue()

    def on_start(self, event):
        print('on_start')
        event.container.selectable(self.events)
        event.container.create_receiver(self.receiver_address)
        event.container.create_sender(self.sender_address, options=AtMostOnce())

    def on_sendable(self, event):
        print('on_sendable')
        self.sender = event.sender
        self.ready_to_send = True
        self.on_message_to_send()
        # TODO: ??? I cannot send my messages from on_sendable because I do not always have something to send here
        # and if I miss one on_sendable and do not send anything, it will not be called again the next time

    def on_message(self, event):
        print("on_message")
        self.gui.receive_message(str(event.message.body))

    def on_message_to_send(self, _=None):
        if not self.ready_to_send:
            return

        while self.sender.credit:
            if self.outgoing_queue.empty():
                return
            message = proton.Message()
            body = self.outgoing_queue.get()
            message.body = body
            self.sender.send(message)

            self.ready_to_send = False

    def send_message(self, body):
        self.outgoing_queue.put(body)
        self.events.trigger(ApplicationEvent('message_to_send'))
Esempio n. 5
0
 def setUp(self):
     import os
     if not hasattr(os, 'pipe'):
       # KAG: seems like Jython doesn't have an os.pipe() method
       raise SkipTest()
     if os.name=="nt":
       # Correct implementation on Windows is complicated
       raise SkipTest("PROTON-1071")
     self.server = ApplicationEventTest.MyTestServer()
     self.server.reactor.handler.add(ApplicationEventTest.MyHandler(self))
     self.event_injector = EventInjector()
     self.hello_event = ApplicationEvent("hello")
     self.goodbye_event = ApplicationEvent("goodbye")
     self.server.reactor.selectable(self.event_injector)
     self.hello_rcvd = None
     self.goodbye_rcvd = None
     self.server.start()
Esempio n. 6
0
 def __init__(self, url, count):
     super(Recv, self).__init__(auto_accept=False)
     self.url = url
     self.delay = 0
     self.last_id = None
     self.expected = count
     self.received = 0
     self.accepted = 0
     self.db = Db("dst_db", EventInjector())
 def __init__(self, aInOAmqpClient):
     super(Recv, self).__init__()
     self.oAmqpClient = aInOAmqpClient
     self.received = 0
     self.ForceDeploy = ForceDeploy(self.oAmqpClient.vsdUserName,
                                    self.oAmqpClient.vsdPassword,
                                    self.oAmqpClient.vsdOrg,
                                    self.oAmqpClient.vsdUrl, LOG,
                                    EventInjector())
Esempio n. 8
0
 def __init__(self, url, count):
     super(Send, self).__init__()
     self.url = url
     self.delay = 0
     self.sent = 0
     self.confirmed = 0
     self.load_count = 0
     self.records = Queue.Queue(maxsize=50)
     self.target = count
     self.db = Db("src_db", EventInjector())
Esempio n. 9
0
class Lock(MessagingHandler):
    def __init__(self, reactor, connection, lock_name, label=None, user_context=None):
        super(Lock, self).__init__(prefetch=0, auto_accept=False, auto_settle=False)
        self.reactor        = reactor
        self.connection     = connection
        self.lock_name      = lock_name
        self.user_context   = user_context
        self.acquired_state = False
        self.events         = EventInjector()
        self.reactor.selectable(self.events)

        self.lock_receiver = None

    def destroy(self):
        if self.acquired_state and self.lock_receiver:
            self.lock_receiver.close()
        self.events.close()

    @property
    def is_acquired(self):
        return self.acquired_state

    def acquire(self):
        if self.acquired_state:
            raise LockException("Lock already acquired")
        self.lock_receiver = self.reactor.create_receiver(self.connection, self.lock_name, handler=self)

    def release(self):
        if not self.acquired_state:
            raise LockException("Lock not acquired")
        self.acquired_state = False
        self.lock_receiver.close()

    def on_link_opened(self, event):
        if event.receiver == self.lock_receiver and event.receiver.remote_source.address == self.lock_name:
            self.acquired_state = True
            new_event = ApplicationEvent("lock_acquired")
            new_event.user_context = self.user_context
            self.events.trigger(new_event)

    def on_link_error(self, event):
        if event.receiver == self.lock_receiver:
            new_event = ApplicationEvent("lock_failed")
            new_event.user_context = self.user_context
            new_event.error        = event.link.remote_condition
            self.events.trigger(new_event)

    def on_link_closed(self, event):
        if event.receiver == self.lock_receiver and self.acquired_state:
            self.acquired_state = False
            new_event = ApplicationEvent("lock_released")
            new_event.user_context = self.user_context
            self.events.trigger(new_event)
Esempio n. 10
0
    def __init__(self, reactor, connection, service_address):
        super(RequestServer, self).__init__(auto_accept=False, auto_settle=False)
        self.service_address = service_address
        self.reactor         = reactor
        self.events          = EventInjector()
        self.reactor.selectable(self.events)

        self.connection       = connection
        self.service_receiver = self.reactor.create_receiver(self.connection, self.service_address, handler=self)
        self.reply_sender     = self.reactor.create_sender(self.connection, None, handler=self)
Esempio n. 11
0
class RequestServer(MessagingHandler):
    def __init__(self, reactor, connection, service_address):
        super(RequestServer, self).__init__(auto_accept=False, auto_settle=False)
        self.service_address = service_address
        self.reactor         = reactor
        self.events          = EventInjector()
        self.reactor.selectable(self.events)

        self.connection       = connection
        self.service_receiver = self.reactor.create_receiver(self.connection, self.service_address, handler=self)
        self.reply_sender     = self.reactor.create_sender(self.connection, None, handler=self)

    def stop(self):
        self.service_receiver.close()
        self.reply_sender.close()
        self.events.close()

    def fail(self, request, message):
        request.in_delivery.local.condition = Condition('sandpiper:bad-request', message)
        self.reject(request.in_delivery)

    def reply(self, request, properties={}, data=None):
        reply_message = Message(properties=properties,
                                body=data,
                                address=request.message.reply_to,
                                correlation_id=request.message.correlation_id)
        request.out_delivery = self.reply_sender.send(reply_message)
        request.out_delivery._request = request

    def on_settled(self, event):
        try:
            request = event.delivery._request
            self.accept(request.in_delivery)
        except:
            pass

    def on_message(self, event):
        request               = Request(event)
        request_event         = ApplicationEvent("request")
        request_event.request = request
        request_event.server  = self
        self.events.trigger(request_event)
Esempio n. 12
0
    def __init__(self, reactor, connection, lock_name, label=None, user_context=None):
        super(Lock, self).__init__(prefetch=0, auto_accept=False, auto_settle=False)
        self.reactor        = reactor
        self.connection     = connection
        self.lock_name      = lock_name
        self.user_context   = user_context
        self.acquired_state = False
        self.events         = EventInjector()
        self.reactor.selectable(self.events)

        self.lock_receiver = None
Esempio n. 13
0
    def __init__(self, reactor, connection, service_address):
        super(RequestClient, self).__init__()
        self.service_address = service_address
        self.reactor         = reactor
        self.events          = EventInjector()
        self.reactor.selectable(self.events)

        self.connection     = connection
        self.service_sender = None
        self.reply_receiver = self.reactor.create_receiver(self.connection, dynamic=True, handler=self)
        self.reply_to       = None
        self.ready          = False
        self.cid            = 1
        self.contexts       = {}
Esempio n. 14
0
 def setUp(self):
     import os
     if not hasattr(os, 'pipe'):
       # KAG: seems like Jython doesn't have an os.pipe() method
       raise SkipTest()
     if os.name=="nt":
       # Correct implementation on Windows is complicated
       raise SkipTest("PROTON-1071")
     self.server = ApplicationEventTest.MyTestServer()
     self.server.reactor.handler.add(ApplicationEventTest.MyHandler(self))
     self.event_injector = EventInjector()
     self.hello_event = ApplicationEvent("hello")
     self.goodbye_event = ApplicationEvent("goodbye")
     self.server.reactor.selectable(self.event_injector)
     self.hello_rcvd = None
     self.goodbye_rcvd = None
     self.server.start()
Esempio n. 15
0
    def test_application_event_no_object_leaks(self):
        event_types_count = len(proton.EventType.TYPES)

        injector = EventInjector()
        p = Program(injector)
        c = Container(p)
        t = threading.Thread(target=c.run)
        t.start()

        p.on_start_.wait()

        object_counts = []

        gc.collect()
        object_counts.append(len(gc.get_objects()))

        for i in range(100):
            injector.trigger(ApplicationEvent("count_up"))

        gc.collect()
        object_counts.append(len(gc.get_objects()))

        self.assertEqual(len(proton.EventType.TYPES), event_types_count + 1)

        injector.trigger(ApplicationEvent("done", subject=c))
        self.assertEqual(len(proton.EventType.TYPES), event_types_count + 2)

        t.join()

        gc.collect()
        object_counts.append(len(gc.get_objects()))

        self.assertEqual(p.counter, 100)

        self.assertTrue(
            object_counts[1] - object_counts[0] <= 220,
            "Object counts should not be increasing too fast: {0}".format(
                object_counts))
        self.assertTrue(
            object_counts[2] - object_counts[0] <= 10,
            "No objects should be leaking at the end: {0}".format(
                object_counts))
Esempio n. 16
0
class RequestClient(MessagingHandler):
    def __init__(self, reactor, connection, service_address):
        super(RequestClient, self).__init__()
        self.service_address = service_address
        self.reactor         = reactor
        self.events          = EventInjector()
        self.reactor.selectable(self.events)

        self.connection     = connection
        self.service_sender = None
        self.reply_receiver = self.reactor.create_receiver(self.connection, dynamic=True, handler=self)
        self.reply_to       = None
        self.ready          = False
        self.cid            = 1
        self.contexts       = {}

    def stop(self):
        self.service_sender.close()
        self.reply_receiver.close()
        self.events.close()

    def request(self, properties={}, body=None, user_context=None):
        cid = self.cid
        self.cid += 1
        request_message = Message(properties     = properties,
                                  body           = body,
                                  reply_to       = self.reply_to,
                                  correlation_id = cid)
        self.contexts[cid] = user_context

        dlv      = self.service_sender.send(request_message)
        dlv._cid = cid

    def on_link_opened(self, event):
        if event.receiver == self.reply_receiver:
            self.reply_to = self.reply_receiver.remote_source.address
            self.service_sender = self.reactor.create_sender(self.connection, self.service_address, handler=self)

    def on_sendable(self, event):
        if not self.ready and event.sender == self.service_sender:
            self.ready = True
            self.events.trigger(ApplicationEvent("service_ready"))

    def on_rejected(self, event):
        dlv = event.delivery
        context = None
        if dlv._cid in self.contexts:
            context = self.contexts[dlv._cid]
        event = ApplicationEvent("request_failed")
        event.context = context
        event.error   = None

    def on_message(self, event):
        reply_message = event.message
        cid           = reply_message.correlation_id
        context       = None
        if cid in self.contexts:
            context = self.contexts[cid]
        new_event              = ApplicationEvent("response")
        new_event.properties   = reply_message.properties
        new_event.body         = reply_message.body
        new_event.user_context = context
        new_event.client       = self
        self.events.trigger(new_event)
Esempio n. 17
0
        self.transaction.commit()

    def on_abort(self, event):
        self.transaction.abort()

    def on_fetch(self, event):
        self.receiver.flow(1)

    def on_quit(self, event):
        c = self.receiver.connection
        self.receiver.close()
        c.close()

try:
    reactor = Container(TxRecv())
    events = EventInjector()
    reactor.selectable(events)
    thread = threading.Thread(target=reactor.run)
    thread.daemon=True
    thread.start()

    print("Enter 'fetch', 'commit' or 'abort'")
    while True:
        line = sys.stdin.readline()
        if line:
            events.trigger(ApplicationEvent(line.strip()))
        else:
            break
except KeyboardInterrupt: pass

Esempio n. 18
0
    def on_abort(self, event):
        self.transaction.abort()

    def on_fetch(self, event):
        self.receiver.flow(1)

    def on_quit(self, event):
        c = self.receiver.connection
        self.receiver.close()
        c.close()


try:
    reactor = Container(TxRecv())
    events = EventInjector()
    reactor.selectable(events)
    thread = threading.Thread(target=reactor.run)
    thread.daemon = True
    thread.start()

    print("Enter 'fetch', 'commit' or 'abort'")
    while True:
        line = sys.stdin.readline()
        if line:
            events.trigger(ApplicationEvent(line.strip()))
        else:
            break
except KeyboardInterrupt:
    pass