Example #1
0
 def dataReceived(self, data):
     """Data received, react to it and respond if needed.
     """
     msg = stomper.unpack_frame(data)
     returned = self.sm.react(msg)
     if returned:
         self.transport.write(returned)
Example #2
0
  def react(self, msg):
    """ Returns an iterable of responses """
    rxdFrame = stomper.unpack_frame(msg)
    cmd = rxdFrame['cmd']

    self.logger.info("Received a %s message." % cmd)
    self.logger.debug("Headers: %s ; Body: %s" % (rxdFrame['headers'], rxdFrame['body']))
    return iter(stomper.Engine.react(self, msg))
Example #3
0
 def dataReceived(self, data):
     all_msgs = data.split('\x00\n')
     for a_msg in all_msgs:
         if a_msg:
             #print 'dr - msg =', a_msg
             msg = stomper.unpack_frame(a_msg)
             returned = self.react(msg)
             if returned:
                 self.transport.write(returned)
Example #4
0
    def testFramepack1(self):
        """Testing pack, unpacking and the Frame class.
        """
        # Check bad frame generation:
        frame = stomper.Frame()

        def bad():
            frame.cmd = 'SOME UNNOWN CMD'

        self.assertRaises(stomper.FrameError, bad)

        # Generate a MESSAGE frame:
        frame = stomper.Frame()
        frame.cmd = 'MESSAGE'
        frame.headers['destination'] = '/queue/a'
        frame.headers['message-id'] = 'card_data'
        frame.body = "hello queue a"
        result = frame.pack()

#        print "\n-- result " + "----" * 10
#        pprint.pprint(result)
#        print

        # Try bad message unpack catching:
        bad_frame = stomper.Frame()
        self.assertRaises(stomper.FrameError, bad_frame.unpack, None)
        self.assertRaises(stomper.FrameError, bad_frame.unpack, '')

        # Try to read the generated frame back in
        # and then check the variables are set up
        # correctly:
        frame2 = stomper.Frame()
        frame2.unpack(result)

        self.assertEquals(frame2.cmd, 'MESSAGE')
        self.assertEquals(frame2.headers['destination'], '/queue/a')
        self.assertEquals(frame2.headers['message-id'], 'card_data')
        self.assertEquals(frame2.body, 'hello queue a')
        result = frame2.pack()

        correct = "MESSAGE\ndestination:/queue/a\nmessage-id:card_data\n\nhello queue a\x00\n"

#        print "result: "
#        pprint.pprint(result)
#        print
#        print "correct: "
#        pprint.pprint(correct)
#        print
#
        self.assertEquals(result, correct)

        result = stomper.unpack_frame(result)

        self.assertEquals(result['cmd'], 'MESSAGE')
        self.assertEquals(result['headers']['destination'], '/queue/a')
        self.assertEquals(result['headers']['message-id'], 'card_data')
        self.assertEquals(result['body'], 'hello queue a')
Example #5
0
    def testFrameUnpack3(self):
        """Testing unpack frame function against CONNECTED
        """
        msg = """CONNECTED
session:ID:snorky.local-49191-1185461799654-3:18
"""
        result = stomper.unpack_frame(msg)

        self.assertEquals(result['cmd'], 'CONNECTED')
        self.assertEquals(result['headers']['session'], 'ID:snorky.local-49191-1185461799654-3:18')
        self.assertEquals(result['body'], '')
Example #6
0
    def testEngine(self):
        """Test the basic state machine.
        """
        e = stomper.Engine(testing=True)

        # test session connected message:
        msg = """CONNECTED
version:1.1
session:ID:snorky.local-49191-1185461799654-3:18

\x00
"""
        result = stomper.unpack_frame(msg)
        correct = ''
        returned = e.react(result)
        self.assertEquals(returned, correct)

        # test message:
        msg = """MESSAGE
subscription:1
destination:/queue/a
message-id:some-message-id
content-type:text/plain

hello queue a

\x00
"""
        returned = e.react(msg)
        correct = 'ACK\nsubscription:1\nmessage-id:some-message-id\n\n\x00\n'
        self.assertEquals(returned, correct)

        # test error:
        msg = """ERROR
message:some error

There was a problem with your last message

\x00
"""
        returned = e.react(msg)
        correct = 'error'
        self.assertEquals(returned, correct)

        # test receipt:
        msg = """RECEIPT
message-id:some-message-id

\x00
"""
        returned = e.react(msg)
        correct = 'receipt'
        self.assertEquals(returned, correct)
    def react(self, msg):
        """Returns an iterable of responses"""
        rxdFrame = stomper.unpack_frame(msg)
        cmd = rxdFrame['cmd']

        self.logger.info("Received a %s message." % cmd)
        self.logger.debug("Headers: %s ; Body: %s" % (rxdFrame['headers'], rxdFrame['body']))
        try:
            res = list(stomper.Engine.react(self, msg))
        except Exception, e:
            self.logger.error(str(e))
            res = stomper.NO_REPONSE_NEEDED
Example #8
0
    def testFrameUnpack3(self):
        """Testing unpack frame function against CONNECTED
        """
        msg = """CONNECTED
session:ID:snorky.local-49191-1185461799654-3:18
"""
        result = stomper.unpack_frame(msg)

        self.assertEquals(result['cmd'], 'CONNECTED')
        self.assertEquals(result['headers']['session'],
                          'ID:snorky.local-49191-1185461799654-3:18')
        self.assertEquals(result['body'], '')
    def testEngine(self):
        """Test the basic state machine.
        """
        e = stomper.Engine(testing=True)

        # test session connected message:
        msg = """CONNECTED
version:1.1
session:ID:snorky.local-49191-1185461799654-3:18

\x00
"""
        result = stomper.unpack_frame(msg)
        correct = ''
        returned = e.react(result)
        self.assertEquals(returned, correct)

        # test message:
        msg = """MESSAGE
subscription:1
destination:/queue/a
message-id:some-message-id
content-type:text/plain

hello queue a

\x00
"""
        returned = e.react(msg)
        correct = 'ACK\nsubscription:1\nmessage-id:some-message-id\n\n\x00\n'
        self.assertEquals(returned, correct)

        # test error:
        msg = """ERROR
message:some error

There was a problem with your last message

\x00
"""
        returned = e.react(msg)
        correct = 'error'
        self.assertEquals(returned, correct)

        # test receipt:
        msg = """RECEIPT
message-id:some-message-id

\x00
"""
        returned = e.react(msg)
        correct = 'receipt'
        self.assertEquals(returned, correct)
Example #10
0
    def dataReceived(self, data):
        """Data received, react to it and respond if needed.
        """
        #print "sender dataReceived: <%s>" % data

        msg = stomper.unpack_frame(data)
        
        returned = self.react(msg)

        #print "sender returned: <%s>" % returned

        if returned:
            self.transport.write(returned)
    def react(self, msg):
        """Returns an iterable of responses"""
        rxdFrame = stomper.unpack_frame(msg)
        cmd = rxdFrame['cmd']

        self.logger.info("Received a %s message." % cmd)
        self.logger.debug("Headers: %s ; Body: %s" %
                          (rxdFrame['headers'], rxdFrame['body']))
        try:
            res = list(stomper.Engine.react(self, msg))
        except Exception, e:
            self.logger.error(str(e))
            res = stomper.NO_REPONSE_NEEDED
Example #12
0
    def test_processCmdResult(self):
        #depends on the implementation of VMWords
        self.cmdRegistry.sendCmdRequest(self.names[0], 'fooCmd')
        rxdFrame = stomper.unpack_frame(self.cmdRegistry.msgSender.data)
        cmdId = rxdFrame['headers']['cmd-id']
        self.assertIn(cmdId, self.cmdRegistry._cmdReqsSent)
        reqSent = self.cmdRegistry._cmdReqsSent[cmdId]

        self.cmdRegistry.processCmdResult(rxdFrame)

        self.assertIn(cmdId, self._cmdReqsRcvd)
        self.assertEquals(reqSent, self._cmdReqsRcvd[cmdId])
        self.assertEquals(reqSent, self._cmdReqsRetired[cmdId])
Example #13
0
    def testFramepack1(self):
        """Testing pack, unpacking and the Frame class.
        """
        # Check bad frame generation:
        frame = stomper.Frame()

        def bad():
            frame.cmd = 'SOME UNNOWN CMD'

        self.assertRaises(stomper.FrameError, bad)

        # Generate a MESSAGE frame:
        frame = stomper.Frame()
        frame.cmd = 'MESSAGE'
        frame.headers['destination'] = '/queue/a'
        frame.headers['message-id'] = 'card_data'
        frame.body = "hello queue a"
        result = frame.pack()

        #        print "\n-- result " + "----" * 10
        #        pprint.pprint(result)
        #        print

        # Try bad message unpack catching:
        bad_frame = stomper.Frame()
        self.assertRaises(stomper.FrameError, bad_frame.unpack, None)
        self.assertRaises(stomper.FrameError, bad_frame.unpack, '')

        # Try to read the generated frame back in
        # and then check the variables are set up
        # correctly:
        frame2 = stomper.Frame()
        frame2.unpack(result)

        self.assertEquals(frame2.cmd, 'MESSAGE')
        self.assertEquals(frame2.headers['destination'], '/queue/a')
        self.assertEquals(frame2.headers['message-id'], 'card_data')
        self.assertEquals(frame2.body, 'hello queue a')
        result = frame2.pack()

        correct = "MESSAGE\ndestination:/queue/a\nmessage-id:card_data\n\nhello queue a\x00\n"

        self.assertEquals(result, correct)

        result = stomper.unpack_frame(result)

        self.assertEquals(result['cmd'], 'MESSAGE')
        self.assertEquals(result['headers']['destination'], '/queue/a')
        self.assertEquals(result['headers']['message-id'], 'card_data')
        self.assertEquals(result['body'], 'hello queue a')
Example #14
0
    def dataReceived(self, data):
        """Data received, react to it and respond if needed.
        """
       	print "receiver dataReceivedalksdfajfja <%s>" % data
        
        msg = stomper.unpack_frame(data)
        print msg
        
        returned = self.sm.react(msg)

        print "receiver returned <%s>" % returned
        
        if returned:
            self.transport.write(returned)
Example #15
0
    def testBugInFrameUnpack1(self):
        msg = """MESSAGE
destination:/queue/a
message-id: card_data

hello queue a

\x00
"""
        result = stomper.unpack_frame(msg)

        self.assertEquals(result['cmd'], 'MESSAGE')
        self.assertEquals(result['headers']['destination'], '/queue/a')
        self.assertEquals(result['headers']['message-id'], 'card_data')
        self.assertEquals(result['body'], 'hello queue a')
Example #16
0
    def testFrameUnpack2(self):
        """Testing unpack frame function against MESSAGE
        """
        msg = """MESSAGE
destination:/queue/a
message-id: card_data

hello queue a"""

        result = stomper.unpack_frame(msg)

        self.assertEquals(result['cmd'], 'MESSAGE')
        self.assertEquals(result['headers']['destination'], '/queue/a')
        self.assertEquals(result['headers']['message-id'], 'card_data')
        self.assertEquals(result['body'], 'hello queue a')
Example #17
0
    def testBugInFrameUnpack1(self):
        msg = """MESSAGE
destination:/queue/a
message-id: card_data

hello queue a

\x00
"""
        result = stomper.unpack_frame(msg)

        self.assertEquals(result['cmd'], 'MESSAGE')
        self.assertEquals(result['headers']['destination'], '/queue/a')
        self.assertEquals(result['headers']['message-id'], 'card_data')
        self.assertEquals(result['body'], 'hello queue a')
Example #18
0
    def testFrameUnpack2(self):
        """Testing unpack frame function against MESSAGE
        """
        msg = """MESSAGE
destination:/queue/a
message-id: card_data

hello queue a"""

        result = stomper.unpack_frame(msg)

        self.assertEquals(result['cmd'], 'MESSAGE')
        self.assertEquals(result['headers']['destination'], '/queue/a')
        self.assertEquals(result['headers']['message-id'], 'card_data')
        self.assertEquals(result['body'], 'hello queue a')
Example #19
0
def on_message(ws, message, c=config):
    print('on_message:', time.strftime("%H:%M:%S", time.localtime()), message)
    print()
    msg = stomper.unpack_frame(message)
    print('keys:', msg.keys())
    print()
    print('values:', msg.values())
    print()
    print('cmd:', msg.get('cmd'))
    print()
    print('headers:', msg.get('headers'))
    print()
    print('subscription:', msg.get('headers').__getitem__('subscription'))
    print()
    print('unPacket:', msg)
    print()
Example #20
0
    def dataReceived(self, data):
        """Data received, react to it and respond if needed.
        """
        print "sender dataReceived: <%s>" % data

        msg = stomper.unpack_frame(data)

        print "msg is lllllll", msg
        
        returned = self.react(msg)
        print "returned ----", returned

        #print "sender returned: <%s>" % returned

        if returned:
            print "+++++++++++++++++"
            self.transport.write(returned)
    def subscribe_person_update(self):
        try:
            ws = create_connection(config.get('websocket-endpoint'))
            ws.send(self.WS_HEADER)
            sub = stomper.subscribe('/topic/person-update', 1)
            ws.send(sub)

            print(Messages.AN_CONNECTOR_CONNECTION_SUCCESSFUL)

            while True:
                try:
                    payload = stomper.unpack_frame(ws.recv())['body']
                    person = Person(payload)
                    self.last_interacting_person = person
                except json.decoder.JSONDecodeError:
                    print(Messages.AN_CONNECTOR_PAYLOAD_ERROR)
                except WebSocketConnectionClosedException:
                    print(Messages.AN_CONNECTOR_CONNECTION_CLOSED)
                    self.subscribe_person_update()
                    break

        except ConnectionRefusedError:
            self.subscribe_person_update()
Example #22
0
    def test_CmdRequest(self):
        self.stompProtocol.makeConnection(self.fakeTransport)
        self.fakeTransport.clear()  #discard connection frames

        for vmName, vmId in zip(self.names, self.ids):
            self.cmdRegistry.sendCmdRequest(vmName, 'fooCmd')

            rxdFrame = stomper.unpack_frame(self.fakeTransport.value())

            self.assertEquals('SEND', rxdFrame['cmd'])
            self.assertEquals('CMD_RUN', rxdFrame['body'])

            headers = rxdFrame['headers']

            self.assertEquals('fooCmd', headers['cmd'])

            rxdCmdId = uuid.UUID(headers['cmd-id'])
            self.assertTrue(isinstance(rxdCmdId, uuid.UUID))

            self.assertEquals(headers['destination'],
                              destinations.CMD_REQ_DESTINATION)

            self.assertEquals(headers['to'], vmId)
            self.fakeTransport.clear()  #discard connection frames
Example #23
0
#
server_response = """CONNECTED
session:ID:snorky.local-49191-1185461799654-3:18

\x00
"""


# We can react to this using the state machine to generate a response.
#
# The state machine can handle the raw message:
response = responder.react(server_response)

# or we could unpack the message into a dict and use it:
#
pprint.pprint(stomper.unpack_frame(response))

resp = responder.react(stomper.unpack_frame(response))

# The engine will store the session id from the CONNECTED
# response. It doesn't generate a message response. It
# just returns an empty string.


# After a successful connect you might want to subscribe
# for messages from a destination and tell the server you'll
# acknowledge all messages.
#
DESTINATION='/queue/inbox'
sub = stomper.subscribe(DESTINATION, ack='client')
Example #24
0
 def dataReceived(self, data):
     msg = stomper.unpack_frame(data)
     returned = self.react(msg)
     if returned:
         self.transport.write(returned)
Example #25
0
 def test_interpretFails(self):
     msg = config.UnknownWord().howToSay()
     self.assertRaises(NameError, \
         lambda: self.msgInterpreter.interpret( stomper.unpack_frame(msg) ) )