def _get_jms_message_header_kwargs(self): hdr_kwargs = {} hdr_annotations = {} for jms_header in list(self.test_headers_map.keys()): value_map = self.test_headers_map[jms_header] value_type = list( value_map.keys())[0] # There is only ever one value in map value = value_map[value_type] if jms_header == 'JMS_TYPE_HEADER': if value_type == 'string': hdr_kwargs['subject'] = value else: raise InteropTestError( 'JmsSenderShim._get_jms_message_header_kwargs(): ' + 'JMS_TYPE_HEADER requires value type "string", type "%s" found' % value_type) elif jms_header == 'JMS_CORRELATIONID_HEADER': if value_type == 'string': hdr_kwargs['correlation_id'] = value elif value_type == 'bytes': hdr_kwargs['correlation_id'] = base64.b64decode(value) else: raise InteropTestError( 'JmsSenderShim._get_jms_message_header_kwargs(): ' + 'JMS_CORRELATIONID_HEADER requires value type "string" or "bytes", ' + 'type "%s" found' % value_type) hdr_annotations[proton.symbol( u'x-opt-app-correlation-id')] = True elif jms_header == 'JMS_REPLYTO_HEADER': if value_type == 'queue': hdr_kwargs['reply_to'] = value hdr_annotations[proton.symbol( u'x-opt-jms-reply-to')] = proton.byte(0) elif value_type == 'topic': hdr_kwargs['reply_to'] = value hdr_annotations[proton.symbol( u'x-opt-jms-reply-to')] = proton.byte(1) elif value_type in ('temp_queue', 'temp_topic'): raise InteropTestError( 'JmsSenderShim._get_jms_message_header_kwargs(): ' + 'JMS_REPLYTO_HEADER type "temp_queue" or "temp_topic" not handled' ) else: raise InteropTestError( 'JmsSenderShim._get_jms_message_header_kwargs(): ' + 'JMS_REPLYTO_HEADER requires value type "queue" or "topic", ' + 'type "%s" found' % value_type) else: raise InteropTestError( 'JmsSenderShim._add_jms_message_headers(): Invalid JMS message header "%s"' % jms_header) return (hdr_kwargs, hdr_annotations)
def _receive_jms_streammessage(self, message): """Receives a JMS stream message""" assert self.jms_msg_type == 'JMS_STREAMMESSAGE_TYPE' assert message.annotations[QPID_JMS_TYPE_ANNOTATION_NAME] == byte(4) # Every message is a list with one item [value] assert len(message.body) == 1 value = message.body[0] if self.current_subtype == 'boolean': return str(value) if self.current_subtype == 'byte': return hex(value) if self.current_subtype == 'bytes': return str(value) if self.current_subtype == 'char': return str(value) if self.current_subtype == 'double': return '0x%016x' % unpack('!Q', pack('!d', value))[0] if self.current_subtype == 'float': return '0x%08x' % unpack('!L', pack('!f', value))[0] if self.current_subtype == 'int': return hex(value) if self.current_subtype == 'long': return hex(int(value)) if self.current_subtype == 'short': return hex(value) if self.current_subtype == 'string': return str(value) raise InteropTestError( 'JmsRecieverShim._receive_jms_streammessage(): ' + 'JMS message type %s: Unknown or unsupported subtype \'%s\'' % (self.jms_msg_type, self.current_subtype))
def _add_jms_message_properties(self, message): """Adds message properties to the supplied message from self.test_properties_map""" for property_name in list(self.test_properties_map.keys()): value_map = self.test_properties_map[property_name] value_type = list(value_map.keys())[0] # There is only ever one value in map value = value_map[value_type] if message.properties is None: message.properties = {} if value_type == 'boolean': message.properties[property_name] = value == 'True' elif value_type == 'byte': message.properties[property_name] = proton.byte(int(value, 16)) elif value_type == 'double': message.properties[property_name] = struct.unpack('!d', _compat.decode_hex(value[2:]))[0] elif value_type == 'float': message.properties[property_name] = proton.float32(struct.unpack('!f', _compat.decode_hex(value[2:]))[0]) elif value_type == 'int': message.properties[property_name] = proton.int32(int(value, 16)) elif value_type == 'long': message.properties[property_name] = _compat.str2long(value, 16) elif value_type == 'short': message.properties[property_name] = proton.short(int(value, 16)) elif value_type == 'string': message.properties[property_name] = value else: raise InteropTestError('JmsSenderShim._add_jms_message_properties: ' + 'Unknown or unhandled message property type ?%s"' % value_type)
def _create_jms_streammessage(self, test_value_type, test_value, hdr_kwargs, hdr_annotations): """Create a JMS stream message""" if test_value_type == 'boolean': body_list = [test_value == 'True'] elif test_value_type == 'byte': body_list = [proton.byte(int(test_value, 16))] elif test_value_type == 'bytes': body_list = [base64.b64decode(test_value)] elif test_value_type == 'char': body_list = [proton.char(base64.b64decode(test_value).decode('utf-8'))] elif test_value_type == 'double': body_list = [struct.unpack('!d', test_value[2:].decode('hex'))[0]] elif test_value_type == 'float': body_list = [proton.float32(struct.unpack('!f', test_value[2:].decode('hex'))[0])] elif test_value_type == 'int': body_list = [proton.int32(int(test_value, 16))] elif test_value_type == 'long': body_list = [_compat.str2long(test_value, 16)] elif test_value_type == 'short': body_list = [proton.short(int(test_value, 16))] elif test_value_type == 'string': body_list = [test_value] else: raise InteropTestError('JmsSenderShim._create_jms_streammessage: Unknown or unsupported subtype "%s"' % test_value_type) return proton.Message(id=(self.sent+1), body=body_list, inferred=True, annotations=JmsHdrsPropsTestSender.merge_dicts(create_annotation('JMS_STREAMMESSAGE_TYPE'), hdr_annotations), **hdr_kwargs)
def _receive_jms_message(self, message): """"Receives a JMS message (without a body)""" assert self.jms_msg_type == 'JMS_MESSAGE_TYPE' assert message.annotations[QPID_JMS_TYPE_ANNOTATION_NAME] == proton.byte(0) if message.body is not None: raise InteropTestError('_receive_jms_message: Invalid body for type JMS_MESSAGE_TYPE: %s' % str(message.body))
def _create_jms_mapmessage(self, test_value_type, test_value, name): """Create a JMS map message""" if test_value_type == 'boolean': value = test_value == 'True' elif test_value_type == 'byte': value = proton.byte(int(test_value, 16)) elif test_value_type == 'bytes': value = test_value.encode('utf-8') elif test_value_type == 'char': value = proton.char(test_value) elif test_value_type == 'double': value = struct.unpack('!d', _compat.decode_hex(test_value[2:]))[0] elif test_value_type == 'float': value = proton.float32( struct.unpack('!f', _compat.decode_hex(test_value[2:]))[0]) elif test_value_type == 'int': value = proton.int32(int(test_value, 16)) elif test_value_type == 'long': value = _compat.str2long(test_value, 16) elif test_value_type == 'short': value = proton.short(int(test_value, 16)) elif test_value_type == 'string': value = test_value else: raise InteropTestError('JmsMessagesTestSender._create_jms_mapmessage: ' \ 'Unknown or unsupported subtype "%s"' % test_value_type) return proton.Message( id=(self.sent + 1), body={name: value}, inferred=False, annotations=create_annotation('JMS_MAPMESSAGE_TYPE'))
def _create_jms_mapmessage(self, test_value_type, test_value, name): """Create a JMS map message""" if test_value_type == 'boolean': value = test_value == 'True' elif test_value_type == 'byte': value = byte(int(test_value, 16)) elif test_value_type == 'bytes': value = str(test_value) # remove unicode elif test_value_type == 'char': value = char(test_value) elif test_value_type == 'double': value = unpack('!d', test_value[2:].decode('hex'))[0] elif test_value_type == 'float': value = float32(unpack('!f', test_value[2:].decode('hex'))[0]) elif test_value_type == 'int': value = int32(int(test_value, 16)) elif test_value_type == 'long': value = long(test_value, 16) elif test_value_type == 'short': value = short(int(test_value, 16)) elif test_value_type == 'string': value = test_value else: raise InteropTestError( 'JmsMessagesTestSender._create_jms_mapmessage: Unknown or unsupported subtype "%s"' % test_value_type) return Message(id=(self.sent + 1), body={name: value}, inferred=False, annotations=create_annotation('JMS_MAPMESSAGE_TYPE'))
def _create_jms_streammessage(self, test_value_type, test_value): """Create a JMS stream message""" if test_value_type == 'boolean': body_list = [test_value == 'True'] elif test_value_type == 'byte': body_list = [byte(int(test_value, 16))] elif test_value_type == 'bytes': body_list = [str(test_value)] elif test_value_type == 'char': body_list = [char(test_value)] elif test_value_type == 'double': body_list = [unpack('!d', test_value[2:].decode('hex'))[0]] elif test_value_type == 'float': body_list = [ float32(unpack('!f', test_value[2:].decode('hex'))[0]) ] elif test_value_type == 'int': body_list = [int32(int(test_value, 16))] elif test_value_type == 'long': body_list = [long(test_value, 16)] elif test_value_type == 'short': body_list = [short(int(test_value, 16))] elif test_value_type == 'string': body_list = [test_value] else: raise InteropTestError( 'JmsMessagesTestSender._create_jms_streammessage: Unknown or unsupported subtype "%s"' % test_value_type) return Message(id=(self.sent + 1), body=body_list, inferred=True, annotations=create_annotation('JMS_STREAMMESSAGE_TYPE'))
def _recieve_jms_mapmessage(self, message): """Receives a JMS map message""" assert self.jms_msg_type == 'JMS_MAPMESSAGE_TYPE' assert message.annotations[ QPID_JMS_TYPE_ANNOTATION_NAME] == proton.byte(2) key, value = list(message.body.items())[0] assert key[:-3] == self.current_subtype if self.current_subtype == 'boolean': return str(value) if self.current_subtype == 'byte': return hex(value) if self.current_subtype == 'bytes': return base64.b64encode(value).decode('utf-8') if self.current_subtype == 'char': if _compat.IS_PY3: return base64.b64encode(bytes(value, 'utf-8')).decode('utf-8') return base64.b64encode(bytes(value)).decode('utf-8') if self.current_subtype == 'double': return '0x%016x' % struct.unpack('!Q', struct.pack('!d', value))[0] if self.current_subtype == 'float': return '0x%08x' % struct.unpack('!L', struct.pack('!f', value))[0] if self.current_subtype == 'int': return hex(value) if self.current_subtype == 'long': return hex(int(value)) if self.current_subtype == 'short': return hex(value) if self.current_subtype == 'string': return str(value) raise InteropTestError( 'JMS message type %s: Unknown or unsupported subtype \'%s\'' % (self.jms_msg_type, self.current_subtype))
def _recieve_jms_mapmessage(self, message): """"Receives a JMS map message""" assert self.jms_msg_type == 'JMS_MAPMESSAGE_TYPE' assert message.annotations[QPID_JMS_TYPE_ANNOTATION_NAME] == byte(2) key, value = message.body.items()[0] assert key[:-3] == self.current_subtype if self.current_subtype == 'boolean': return str(value) if self.current_subtype == 'byte': return hex(value) if self.current_subtype == 'bytes': return str(value) if self.current_subtype == 'char': return str(value) if self.current_subtype == 'double': return '0x%016x' % unpack('!Q', pack('!d', value))[0] if self.current_subtype == 'float': return '0x%08x' % unpack('!L', pack('!f', value))[0] if self.current_subtype == 'int': return hex(value) if self.current_subtype == 'long': return hex(int(value)) if self.current_subtype == 'short': return hex(value) if self.current_subtype == 'string': return str(value) raise InteropTestError( 'JMS message type %s: Unknown or unsupported subtype \'%s\'' % (self.jms_msg_type, self.current_subtype))
def _create_jms_mapmessage(self, test_value_type, test_value, name, hdr_kwargs, hdr_annotations): """Create a JMS map message""" if test_value_type == 'boolean': value = test_value == 'True' elif test_value_type == 'byte': value = proton.byte(int(test_value, 16)) elif test_value_type == 'bytes': value = base64.b64decode(test_value) elif test_value_type == 'char': value = proton.char(base64.b64decode(test_value).decode('utf-8')) elif test_value_type == 'double': value = struct.unpack('!d', test_value[2:].decode('hex'))[0] elif test_value_type == 'float': value = proton.float32( struct.unpack('!f', test_value[2:].decode('hex'))[0]) elif test_value_type == 'int': value = proton.int32(int(test_value, 16)) elif test_value_type == 'long': value = int(test_value, 16) elif test_value_type == 'short': value = proton.short(int(test_value, 16)) elif test_value_type == 'string': value = test_value else: raise InteropTestError( 'JmsSenderShim._create_jms_mapmessage: Unknown or unsupported subtype "%s"' % test_value_type) return proton.Message(id=(self.sent + 1), body={name: value}, inferred=False, annotations=JmsHdrsPropsTestSender.merge_dicts( create_annotation('JMS_MAPMESSAGE_TYPE'), hdr_annotations), **hdr_kwargs)
def encode_amqp_type(amqp_type, test_value): """Encode an AMQP type from a stringified test_value""" if amqp_type == 'null': return None if amqp_type == 'boolean': return True if test_value == 'True' else False if amqp_type == 'ubyte': return proton.ubyte(int(test_value, 16)) if amqp_type == 'ushort': return proton.ushort(int(test_value, 16)) if amqp_type == 'uint': return proton.uint(int(test_value, 16)) if amqp_type == 'ulong': return proton.ulong(int(test_value, 16)) if amqp_type == 'byte': return proton.byte(int(test_value, 16)) if amqp_type == 'short': return proton.short(int(test_value, 16)) if amqp_type == 'int': return proton.int32(int(test_value, 16)) if amqp_type == 'long': return _compat.str2long(test_value, 16) if amqp_type == 'float': return proton.float32(struct.unpack('!f', _compat.decode_hex(test_value[2:]))[0]) if amqp_type == 'double': return struct.unpack('!d', _compat.decode_hex(test_value[2:]))[0] if amqp_type == 'decimal32': return proton.decimal32(int(test_value[2:], 16)) if amqp_type == 'decimal64': return proton.decimal64(_compat.str2long(test_value[2:], 16)) if amqp_type == 'decimal128': return proton.decimal128(_compat.decode_hex(test_value[2:])) if amqp_type == 'char': if len(test_value) == 1: # Format 'a' return proton.char(test_value) return proton.char(_compat.unichr(int(test_value, 16))) if amqp_type == 'timestamp': return proton.timestamp(int(test_value, 16)) if amqp_type == 'uuid': return uuid.UUID(test_value) if amqp_type == 'binary': return test_value.encode('utf-8') if amqp_type == 'string': return _compat.unicode(test_value) if amqp_type == 'symbol': return proton.symbol(test_value) if amqp_type == 'list': return AmqpTypesTestSender.encode_amqp_list(test_value) if amqp_type == 'map': return AmqpTypesTestSender.encode_amqp_map(test_value) if amqp_type == 'array': #return AmqpTypesTestSender.encode_amqp_array(test_value) print('send: Unsupported AMQP type "%s"' % amqp_type) return None print('send: Unknown AMQP type "%s"' % amqp_type) return None
def _receive_jms_bytesmessage(self, message): """Receives a JMS bytes message""" assert self.jms_msg_type == 'JMS_BYTESMESSAGE_TYPE' assert message.annotations[ QPID_JMS_TYPE_ANNOTATION_NAME] == proton.byte(3) if self.current_subtype == 'boolean': if message.body == b'\x00': return 'False' if message.body == b'\x01': return 'True' raise InteropTestError( '_receive_jms_bytesmessage: Invalid encoding for subtype boolean: %s' % str(message.body)) if self.current_subtype == 'byte': return hex(struct.unpack('b', message.body)[0]) if self.current_subtype == 'bytes': return base64.b64encode(message.body).decode('utf-8') if self.current_subtype == 'char': if len(message.body) == 2: # format 'a' or '\xNN' if _compat.IS_PY3: return base64.b64encode(bytes([message.body[1]])).decode( 'utf-8') # strip leading '\x00' char return base64.b64encode(bytes(message.body[1])).decode( 'utf-8') # strip leading '\x00' char raise InteropTestError( 'Unexpected string length for type char: %d' % len(message.body)) if self.current_subtype == 'double': return '0x%016x' % struct.unpack('!Q', message.body)[0] if self.current_subtype == 'float': return '0x%08x' % struct.unpack('!L', message.body)[0] if self.current_subtype == 'int': return hex(struct.unpack('!i', message.body)[0]) if self.current_subtype == 'long': return hex(struct.unpack('!q', message.body)[0]) if self.current_subtype == 'short': return hex(struct.unpack('!h', message.body)[0]) if self.current_subtype == 'string': # NOTE: first 2 bytes are string length, must be present if len(message.body) >= 2: str_len = struct.unpack('!H', message.body[:2])[0] str_body = message.body[2:].decode('utf-8') if len(str_body) != str_len: raise InteropTestError( 'String length mismatch: size=%d, but len(\'%s\')=%d' % (str_len, str_body, len(str_body))) return str_body raise InteropTestError('Malformed string binary: len(\'%s\')=%d' % (repr(message.body), len(message.body))) raise InteropTestError( 'JMS message type %s: Unknown or unsupported subtype \'%s\'' % (self.jms_msg_type, self.current_subtype))
def _create_jms_streammessage(self, test_value_type, test_value): """Create a JMS stream message""" if test_value_type == 'boolean': body_list = [test_value == 'True'] elif test_value_type == 'byte': body_list = [proton.byte(int(test_value, 16))] elif test_value_type == 'bytes': body_list = [test_value.encode('utf-8')] elif test_value_type == 'char': body_list = [proton.char(test_value)] elif test_value_type == 'double': body_list = [ struct.unpack('!d', _compat.decode_hex(test_value[2:]))[0] ] elif test_value_type == 'float': body_list = [ proton.float32( struct.unpack('!f', _compat.decode_hex(test_value[2:]))[0]) ] elif test_value_type == 'int': body_list = [proton.int32(int(test_value, 16))] elif test_value_type == 'long': body_list = [_compat.str2long(test_value, 16)] elif test_value_type == 'short': body_list = [proton.short(int(test_value, 16))] elif test_value_type == 'string': body_list = [test_value] else: raise InteropTestError('JmsMessagesTestSender._create_jms_streammessage: ' \ 'Unknown or unsupported subtype "%s"' % test_value_type) return proton.Message( id=(self.sent + 1), body=body_list, inferred=True, annotations=create_annotation('JMS_STREAMMESSAGE_TYPE'))
# # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, # software distributed under the License is distributed on an # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See the License for the # specific language governing permissions and limitations # under the License. # from proton import byte, symbol QPID_JMS_TYPE_ANNOTATION_NAME = symbol(u'x-opt-jms-msg-type') QPID_JMS_TYPE_ANNOTATIONS = { 'JMS_MESSAGE_TYPE': byte(0), 'JMS_BYTESMESSAGE_TYPE': byte(3), 'JMS_MAPMESSAGE_TYPE': byte(2), 'JMS_OBJECTMESSAGE_TYPE': byte(1), 'JMS_STREAMMESSAGE_TYPE': byte(4), 'JMS_TEXTMESSAGE_TYPE': byte(5) } def create_annotation(jms_msg_type): """Function which creates a message annotation for JMS message type as used by the Qpid JMS client""" return { QPID_JMS_TYPE_ANNOTATION_NAME: QPID_JMS_TYPE_ANNOTATIONS[jms_msg_type] }
def create_message(self, test_value): """ Creates a single message with the test value translated from its string representation to the appropriate AMQP value (set in self.amqp_type). """ if self.amqp_type == 'null': return Message(id=(self.sent + 1), body=None) elif self.amqp_type == 'boolean': return Message(id=(self.sent + 1), body=True if test_value == 'True' else False) elif self.amqp_type == 'ubyte': return Message(id=(self.sent + 1), body=ubyte(int(test_value, 16))) elif self.amqp_type == 'ushort': return Message(id=(self.sent + 1), body=ushort(int(test_value, 16))) elif self.amqp_type == 'uint': return Message(id=(self.sent + 1), body=uint(int(test_value, 16))) elif self.amqp_type == 'ulong': return Message(id=(self.sent + 1), body=ulong(int(test_value, 16))) elif self.amqp_type == 'byte': return Message(id=(self.sent + 1), body=byte(int(test_value, 16))) elif self.amqp_type == 'short': return Message(id=(self.sent + 1), body=short(int(test_value, 16))) elif self.amqp_type == 'int': return Message(id=(self.sent + 1), body=int32(int(test_value, 16))) elif self.amqp_type == 'long': return Message(id=(self.sent + 1), body=long(int(test_value, 16))) elif self.amqp_type == 'float': return Message(id=(self.sent + 1), body=float32( unpack('!f', test_value[2:].decode('hex'))[0])) elif self.amqp_type == 'double': return Message(id=(self.sent + 1), body=unpack('!d', test_value[2:].decode('hex'))[0]) elif self.amqp_type == 'decimal32': return Message(id=(self.sent + 1), body=decimal32(int(test_value[2:], 16))) elif self.amqp_type == 'decimal64': l64 = long(test_value[2:], 16) return Message(id=(self.sent + 1), body=decimal64(l64)) elif self.amqp_type == 'decimal128': return Message(id=(self.sent + 1), body=decimal128(test_value[2:].decode('hex'))) elif self.amqp_type == 'char': if len(test_value) == 1: # Format 'a' return Message(id=(self.sent + 1), body=char(test_value)) else: val = int(test_value, 16) return Message(id=(self.sent + 1), body=char(unichr(val))) elif self.amqp_type == 'timestamp': return Message(id=(self.sent + 1), body=timestamp(int(test_value, 16))) elif self.amqp_type == 'uuid': return Message(id=(self.sent + 1), body=UUID(test_value)) elif self.amqp_type == 'binary': return Message(id=(self.sent + 1), body=bytes(test_value)) elif self.amqp_type == 'string': return Message(id=(self.sent + 1), body=unicode(test_value)) elif self.amqp_type == 'symbol': return Message(id=(self.sent + 1), body=symbol(test_value)) elif self.amqp_type == 'list': return Message(id=(self.sent + 1), body=test_value) elif self.amqp_type == 'map': return Message(id=(self.sent + 1), body=test_value) else: print 'send: Unsupported AMQP type "%s"' % self.amqp_type return None
def _receive_jms_textmessage(self, message): """"Receives a JMS text message""" assert self.jms_msg_type == 'JMS_TEXTMESSAGE_TYPE' assert message.annotations[QPID_JMS_TYPE_ANNOTATION_NAME] == byte(5) return message.body
def _recieve_jms_objectmessage(self, message): """"Receives a JMS Object message""" assert self.jms_msg_type == 'JMS_OBJECTMESSAGE_TYPE' assert message.annotations[QPID_JMS_TYPE_ANNOTATION_NAME] == byte(1) return self._get_java_obj(message.body)