def test_invalid_protocol_header(self):
     with self.assertRaises(exceptions.UnmarshalingException) as err:
         frame.unmarshal(b'AMQP\x00\x00\t')
         self.assertTrue(
             str(err).startswith(
                 "Could not unmarshal <class 'pamqp.header.ProtocolHeader'> "
                 'frame: Data did not match the ProtocolHeader format'))
 def test_frame_with_no_length(self):
     frame_data = (b'\x01\x00\x01\x00\x00\x00\x00\x00<\x00P\x00\x00\x00\x00'
                   b'\x00\x00\x00\x01\x00\xce')
     with self.assertRaises(exceptions.UnmarshalingException) as err:
         frame.unmarshal(frame_data)
         self.assertEqual(
             str(err), 'Could not unmarshal Unknown frame: No frame size')
 def test_frame_malformed_end_byte(self):
     frame_data = (b'\x01\x00\x01\x00\x00\x00\r\x00<\x00P\x00\x00\x00\x00'
                   b'\x00\x00\x00\x01\x00\x00')
     with self.assertRaises(exceptions.UnmarshalingException) as err:
         frame.unmarshal(frame_data)
         self.assertEqual(
             str(err), 'Could not unmarshal Unknown frame: Last byte error')
 def test_frame_malformed_length(self):
     frame_data = (b'\x01\x00\x01\x00\x00\x00\x0c\x00<\x00P\x00\x00\x00\x00'
                   b'\x00\x00\x00\xce')
     with self.assertRaises(exceptions.UnmarshalingException) as err:
         frame.unmarshal(frame_data)
         self.assertEqual(
             str(err),
             'Could not unmarshal Unknown frame: Not all data received')
Example #5
0
 def test_invalid_frame_header(self):
     frame_data = struct.pack('>BI', 255, 0)
     try:
         frame.unmarshal(frame_data)
     except exceptions.UnmarshalingException as err:
         self.assertEqual(
             str(err), 'Could not unmarshal Unknown frame: No frame size')
     else:
         assert False, 'Failed to raise exception'
 def test_invalid_protocol_header(self):
     try:
         frame.unmarshal(b'AMQP\x00\x00\t')
     except exceptions.UnmarshalingException as err:
         self.assertTrue(str(err).startswith(
             "Could not unmarshal <class 'pamqp.header.ProtocolHeader'> "
             'frame: Data did not match the ProtocolHeader format'))
     else:
         assert False, 'Failed to raise exception'
 def test_invalid_frame_header(self):
     frame_data = struct.pack('>BI', 255, 0)
     try:
         frame.unmarshal(frame_data)
     except exceptions.UnmarshalingException as err:
         self.assertEqual(
             str(err), 'Could not unmarshal Unknown frame: No frame size')
     else:
         assert False, 'Failed to raise exception'
 def test_invalid_method_frame_index(self):
     payload = struct.pack('>L', 42949)
     frame_value = b''.join([
         struct.pack('>BHI', 1, 0, len(payload)), payload,
         constants.FRAME_END_CHAR
     ])
     with self.assertRaises(exceptions.UnmarshalingException) as err:
         frame.unmarshal(frame_value)
         self.assertEqual(str(err), ('Could not unmarshal Unknown frame: '
                                     'Unknown method index: 42949'))
Example #9
0
 def test_invalid_protocol_header(self):
     try:
         frame.unmarshal(b'AMQP\x00\x00\t')
     except exceptions.UnmarshalingException as err:
         self.assertTrue(
             str(err).startswith(
                 "Could not unmarshal <class 'pamqp.header.ProtocolHeader'> "
                 "frame: Data did not match the ProtocolHeader format"))
     else:
         assert False, 'Failed to raise exception'
 def test_frame_with_no_length(self):
     frame_data = (b'\x01\x00\x01\x00\x00\x00\x00\x00<\x00P\x00\x00\x00\x00'
                   b'\x00\x00\x00\x01\x00\xce')
     try:
         frame.unmarshal(frame_data)
     except exceptions.UnmarshalingException as err:
         self.assertEqual(
             str(err), 'Could not unmarshal Unknown frame: No frame size')
     else:
         assert False, 'Failed to raise exception'
Example #11
0
 def test_frame_malformed_end_byte(self):
     frame_data = (b'\x01\x00\x01\x00\x00\x00\r\x00<\x00P\x00\x00\x00\x00'
                   b'\x00\x00\x00\x01\x00\x00')
     try:
         frame.unmarshal(frame_data)
     except exceptions.UnmarshalingException as err:
         self.assertEqual(
             str(err), 'Could not unmarshal Unknown frame: Last byte error')
     else:
         assert False, 'Failed to raise exception'
Example #12
0
 def test_frame_with_no_length(self):
     frame_data = (b'\x01\x00\x01\x00\x00\x00\x00\x00<\x00P\x00\x00\x00\x00'
                   b'\x00\x00\x00\x01\x00\xce')
     try:
         frame.unmarshal(frame_data)
     except exceptions.UnmarshalingException as err:
         self.assertEqual(
             str(err), 'Could not unmarshal Unknown frame: No frame size')
     else:
         assert False, 'Failed to raise exception'
 def test_malformed_frame_content(self):
     payload = struct.pack('>HxxQ', 8192, 32768)
     frame_value = b''.join([
         struct.pack('>BHI', 5, 0, len(payload)), payload,
         constants.FRAME_END_CHAR
     ])
     with self.assertRaises(exceptions.UnmarshalingException) as err:
         frame.unmarshal(frame_value)
         self.assertEqual(
             str(err),
             'Could not unmarshal Unknown frame: Unknown frame type: 5')
 def test_invalid_method_frame_content(self):
     payload = struct.pack('>L', 0x000A0029)
     frame_value = b''.join([struct.pack('>BHI', 1, 0, len(payload)),
                             payload, frame.FRAME_END_CHAR])
     try:
         frame.unmarshal(frame_value)
     except exceptions.UnmarshalingException as err:
         self.assertTrue(str(err).startswith(
             'Could not unmarshal <pamqp.specification.Connection.OpenOk'))
     else:
         assert False, 'Failed to raise exception'
Example #15
0
 def test_frame_malformed_length(self):
     frame_data = (b'\x01\x00\x01\x00\x00\x00\x0c\x00<\x00P\x00\x00\x00\x00'
                   b'\x00\x00\x00\xce')
     try:
         frame.unmarshal(frame_data)
     except exceptions.UnmarshalingException as err:
         self.assertEqual(
             str(err),
             'Could not unmarshal Unknown frame: Not all data received')
     else:
         assert False, 'Failed to raise exception'
 def test_invalid_content_header_frame(self):
     payload = struct.pack('>L', 0x000A0029)
     frame_value = b''.join([struct.pack('>BHI', 2, 0, len(payload)),
                             payload, frame.FRAME_END_CHAR])
     try:
         frame.unmarshal(frame_value)
     except exceptions.UnmarshalingException as err:
         self.assertTrue(str(err).startswith(
             'Could not unmarshal ContentHeader frame:'))
     else:
         assert False, 'Failed to raise exception'
 def test_frame_malformed_length(self):
     frame_data = (b'\x01\x00\x01\x00\x00\x00\x0c\x00<\x00P\x00\x00\x00\x00'
                   b'\x00\x00\x00\xce')
     try:
         frame.unmarshal(frame_data)
     except exceptions.UnmarshalingException as err:
         self.assertEqual(
             str(err),
             'Could not unmarshal Unknown frame: Not all data received')
     else:
         assert False, 'Failed to raise exception'
 def test_frame_malformed_end_byte(self):
     frame_data = (b'\x01\x00\x01\x00\x00\x00\r\x00<\x00P\x00\x00\x00\x00'
                   b'\x00\x00\x00\x01\x00\x00')
     try:
         frame.unmarshal(frame_data)
     except exceptions.UnmarshalingException as err:
         self.assertEqual(
             str(err),
             'Could not unmarshal Unknown frame: Last byte error')
     else:
         assert False, 'Failed to raise exception'
 def test_invalid_content_header_frame(self):
     payload = struct.pack('>L', 0x000A0029)
     frame_value = b''.join([
         struct.pack('>BHI', 2, 0, len(payload)), payload,
         constants.FRAME_END_CHAR
     ])
     with self.assertRaises(exceptions.UnmarshalingException) as err:
         frame.unmarshal(frame_value)
         self.assertTrue(
             str(err).startswith(
                 'Could not unmarshal ContentHeader frame:'))
 def test_malformed_frame_content(self):
     payload = struct.pack('>HxxQ', 8192, 32768)
     frame_value = b''.join([struct.pack('>BHI', 5, 0, len(payload)),
                             payload, frame.FRAME_END_CHAR])
     try:
         frame.unmarshal(frame_value)
     except exceptions.UnmarshalingException as err:
         self.assertEqual(
             str(err),
             'Could not unmarshal Unknown frame: Unknown frame type: 5')
     else:
         assert False, 'Failed to raise exception'
 def test_invalid_method_frame_content(self):
     payload = struct.pack('>L', 0x000A0029)
     frame_value = b''.join([
         struct.pack('>BHI', 1, 0, len(payload)), payload,
         constants.FRAME_END_CHAR
     ])
     with self.assertRaises(exceptions.UnmarshalingException) as err:
         frame.unmarshal(frame_value)
         self.assertTrue(
             str(err).startswith(
                 'Could not unmarshal <pamqp.specification.Connection.OpenOk'
             ))
Example #22
0
 def test_invalid_method_frame_index(self):
     payload = struct.pack('>L', 42949)
     frame_value = b''.join([
         struct.pack('>BHI', 1, 0, len(payload)), payload,
         frame.FRAME_END_CHAR
     ])
     try:
         frame.unmarshal(frame_value)
     except exceptions.UnmarshalingException as err:
         self.assertEqual(str(err), ('Could not unmarshal Unknown frame: '
                                     'Unknown method index: 42949'))
     else:
         assert False, 'Failed to raise exception'
 def test_invalid_method_frame_index(self):
     payload = struct.pack('>L', 42949)
     frame_value = b''.join([struct.pack('>BHI', 1, 0, len(payload)),
                             payload, frame.FRAME_END_CHAR])
     try:
         frame.unmarshal(frame_value)
     except exceptions.UnmarshalingException as err:
         self.assertEqual(
             str(err),
             ('Could not unmarshal Unknown frame: '
              'Unknown method index: 42949'))
     else:
         assert False, 'Failed to raise exception'
Example #24
0
 def test_malformed_frame_content(self):
     payload = struct.pack('>HxxQ', 8192, 32768)
     frame_value = b''.join([
         struct.pack('>BHI', 5, 0, len(payload)), payload,
         frame.FRAME_END_CHAR
     ])
     try:
         frame.unmarshal(frame_value)
     except exceptions.UnmarshalingException as err:
         self.assertEqual(
             str(err),
             'Could not unmarshal Unknown frame: Unknown frame type: 5')
     else:
         assert False, 'Failed to raise exception'
Example #25
0
 def test_invalid_content_header_frame(self):
     payload = struct.pack('>L', 0x000A0029)
     frame_value = b''.join([
         struct.pack('>BHI', 2, 0, len(payload)), payload,
         frame.FRAME_END_CHAR
     ])
     try:
         frame.unmarshal(frame_value)
     except exceptions.UnmarshalingException as err:
         self.assertTrue(
             str(err).startswith(
                 'Could not unmarshal ContentHeader frame:'))
     else:
         assert False, 'Failed to raise exception'
Example #26
0
 def test_invalid_method_frame_content(self):
     payload = struct.pack('>L', 0x000A0029)
     frame_value = b''.join([
         struct.pack('>BHI', 1, 0, len(payload)), payload,
         frame.FRAME_END_CHAR
     ])
     try:
         frame.unmarshal(frame_value)
     except exceptions.UnmarshalingException as err:
         self.assertTrue(
             str(err).startswith(
                 'Could not unmarshal <pamqp.specification.Connection.OpenOk'
             ))
     else:
         assert False, 'Failed to raise exception'
Example #27
0
 def data_received(self, data: bytes) -> None:
     self.buffer += data
     while self.buffer:
         try:
             count, channel, value = frame.unmarshal(self.buffer)
         except exceptions.UnmarshalingException as error:
             LOGGER.warning('Failed to unmarshal a frame: %r', error)
             LOGGER.debug('Bad frame: %r', self.buffer)
             break
         else:
             self.buffer = self.buffer[count:]
             self.loop.call_soon(self.on_frame_received, channel, value)
    async def _reader_task(self, reader: StreamReader) -> None:
        buffer = b""
        while not reader.at_eof():
            chunk = await reader.read(1)
            if not chunk:
                break
            buffer += chunk
            try:
                byte_count, channel_id, frame = unmarshal(buffer)
            except UnmarshalingException:
                continue
            else:
                buffer = b""

            _logger.debug(f"<- {frame.name} {channel_id}")
            await self.dispatch_frame(frame, channel_id)
Example #29
0
    def _handle_amqp_frame(data_in):
        """Unmarshal any incoming RabbitMQ frames and return the result.

        :param data_in: socket data
        :return: buffer, channel_id, frame
        """
        if not data_in:
            return data_in, None, None
        try:
            byte_count, channel_id, frame_in = pamqp_frame.unmarshal(data_in)
            return data_in[byte_count:], channel_id, frame_in
        except pamqp_exception.UnmarshalingException:
            return data_in, None, None
        except pamqp_spec.AMQPFrameError as why:
            LOGGER.error('AMQPFrameError: %r', why, exc_info=True)
            return data_in, None, None
Example #30
0
    def _handle_amqp_frame(data_in):
        """Unmarshal any incoming RabbitMQ frames and return the result.

        :param data_in: socket data
        :return: buffer, channel_id, frame
        """
        if not data_in:
            return data_in, None, None
        try:
            byte_count, channel_id, frame_in = pamqp_frame.unmarshal(data_in)
            return data_in[byte_count:], channel_id, frame_in
        except pamqp_exception.UnmarshalingException:
            return data_in, None, None
        except pamqp_spec.AMQPFrameError as why:
            LOGGER.error('AMQPFrameError: %r', why, exc_info=True)
            return data_in, None, None
Example #31
0
    def _handle_amqp_frame(self, data_in):
        """Unmarshal a single AMQP frame and return the result.

        :param data_in: socket data
        :return: data_in, channel_id, frame
        """
        if not data_in:
            return data_in, None, None
        try:
            byte_count, channel_id, frame_in = pamqp_frame.unmarshal(data_in)
            return data_in[byte_count:], channel_id, frame_in
        except pamqp_exception.UnmarshalingException:
            pass
        except pamqp_spec.AMQPFrameError as why:
            LOGGER.error('AMQPFrameError: %r', why, exc_info=True)
        except ValueError as why:
            LOGGER.error(why, exc_info=True)
            self.exceptions.append(AMQPConnectionError(why))
        return data_in, None, None
Example #32
0
    def _handle_amqp_frame(self, data_in):
        """Unmarshal a single AMQP frame and return the result.

        :param data_in: socket data
        :return: data_in, channel_id, frame
        """
        if not data_in:
            return data_in, None, None
        try:
            byte_count, channel_id, frame_in = pamqp_frame.unmarshal(data_in)
            return data_in[byte_count:], channel_id, frame_in
        except pamqp_exception.UnmarshalingException:
            pass
        except specification.AMQPFrameError as why:
            LOGGER.error('AMQPFrameError: %r', why, exc_info=True)
        except ValueError as why:
            LOGGER.error(why, exc_info=True)
            self.exceptions.append(AMQPConnectionError(why))
        return data_in, None, None
Example #33
0
    def _get_frame_from_str(value):
        """Get the pamqp frame from the string value.

        :param str value: The value to parse for an pamqp frame
        :return (str, int, pamqp.specification.Frame): Remainder of value,
                                                       channel id and
                                                       frame value
        """
        if not value:
            return value, None, None
        try:
            byte_count, channel_id, frame_in = frame.unmarshal(value)
        except pamqp_exceptions.UnmarshalingException:
            return value, None, None
        except specification.AMQPFrameError as error:
            LOGGER.error('Failed to demarshal: %r', error, exc_info=True)
            LOGGER.debug(value)
            return value, None, None
        return value[byte_count:], channel_id, frame_in
Example #34
0
    def _get_frame_from_str(value):
        """Get the pamqp frame from the string value.

        :param str value: The value to parse for an pamqp frame
        :return (str, int, pamqp.specification.Frame): Remainder of value,
                                                       channel id and
                                                       frame value
        """
        if not value:
            return value, None, None
        try:
            byte_count, channel_id, frame_in = frame.unmarshal(value)
        except pamqp_exceptions.UnmarshalingException:
            return value, None, None
        except specification.AMQPFrameError as error:
            LOGGER.error('Failed to demarshal: %r', error, exc_info=True)
            LOGGER.debug(value)
            return value, None, None
        return value[byte_count:], channel_id, frame_in
Example #35
0
 def _transport_write(self, value: bytes) -> typing.NoReturn:
     count, channel, frame_value = frame.unmarshal(value)
     self.assertEqual(count, len(value), 'All bytes used')
     self.assertEqual(channel, 0, 'Frame was published on channel 0')
     if frame_value.name == 'ProtocolHeader':
         self.loop.call_soon(self._connection_start)
     elif frame_value.name == 'Connection.StartOk':
         self.loop.call_soon(self._connection_tune)
     elif frame_value.name == 'Connection.TuneOk':
         pass
     elif frame_value.name == 'Connection.Open':
         self.loop.call_soon(self._connection_open_ok)
     elif frame_value.name == 'Connection.Close':
         self.loop.call_soon(self._connection_close_ok)
     elif frame_value.name == 'Connection.CloseOk':
         pass
     elif frame_value.name == 'Heartbeat':
         self.heartbeat.set()
     else:
         raise RuntimeError(count, channel, frame_value)
 def test_invalid_frame_header(self):
     frame_data = struct.pack('>BI', 255, 0)
     with self.assertRaises(exceptions.UnmarshalingException) as err:
         frame.unmarshal(frame_data)
         self.assertEqual(
             str(err), 'Could not unmarshal Unknown frame: No frame size')