# ------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. # -------------------------------------------------------------------------- # pylint: disable=too-many-lines import logging from uamqp import c_uamqp, constants, errors, utils _logger = logging.getLogger(__name__) class Message(object): """An AMQP message. When sending, if body type information is not provided, then depending on the nature of the data, different body encoding will be used. If the data is str or bytes, a single part DataBody will be sent. If the data is a list of str/bytes, a multipart DataBody will be sent. Any other type of list or any other type of data will be sent as a ValueBody. An empty payload will also be sent as a ValueBody. If body type information is provided, then the Message will use the given body type to encode the data or raise error if the data doesn't match the body type. :ivar on_send_complete: A custom callback to be run on completion of the send operation of this message. The callback must take two parameters, a result (of type `MessageSendResult`) and an error (of type Exception). The error parameter may be None if no error ocurred or the error information was undetermined. :vartype on_send_complete: callable[~uamqp.constants.MessageSendResult, Exception] :param body: The data to send in the message. :type body: Any Python data type. :param properties: Properties to add to the message. :type properties: ~uamqp.message.MessageProperties :param application_properties: Service specific application properties. :type application_properties: dict :param annotations: Service specific message annotations. Keys in the dictionary must be `types.AMQPSymbol` or `types.AMQPuLong`. :type annotations: dict :param header: The message header. :type header: ~uamqp.message.MessageHeader :param msg_format: A custom message format. Default is 0. :type msg_format: int :param message: Internal only. This is used to wrap an existing message that has been received from an AMQP service. If specified, all other parameters will be ignored. :type message: uamqp.c_uamqp.cMessage :param settler: Internal only. This is used when wrapping an existing message that has been received from an AMQP service. Should only be specified together with `message` and is to settle the message. :type settler: callable[~uamqp.errors.MessageResponse] :param delivery_no: Internal only. This is used when wrapping an existing message that has been received from an AMQP service. Should only be specified together with `message` and specifies the messages client delivery number. :param encoding: The encoding to use for parameters supplied as strings. Default is 'UTF-8' :type encoding: str :param body_type: The AMQP body type used to specify the type of the body section of an amqp message. By default is None which means depending on the nature of the data, different body encoding will be used. If the data is str or bytes, a single part DataBody will be sent. If the data is a list of str/bytes, a multipart DataBody will be sent. Any other type of list or any other type of data will be sent as a ValueBody. An empty payload will also be sent as a ValueBody. Please check class ~uamqp.MessageBodyType for usage information of each body type. :type body_type: ~uamqp.MessageBodyType :param footer: The message footer. :type footer: dict :param delivery_annotations: Service specific delivery annotations. :type delivery_annotations: dict """ def __init__( self, body=None, properties=None, application_properties=None, annotations=None, header=None, msg_format=None, message=None, settler=None, delivery_no=None, encoding='UTF-8', body_type=None, footer=None, delivery_annotations=None ): self.state = constants.MessageState.WaitingToBeSent self.idle_time = 0 self.retries = 0 self._response = None self._settler = None self._encoding = encoding self.delivery_no = delivery_no self.delivery_tag = None self.on_send_complete = None self._properties = None self._application_properties = None self._annotations = None self._header = None self._footer = None self._delivery_annotations = None self._need_further_parse = False if message: if settler: self.state = constants.MessageState.ReceivedUnsettled self._response = None else: self.state = constants.MessageState.ReceivedSettled self._response = errors.MessageAlreadySettled() self._settler = settler self._parse_message_body(message) else: self._message = c_uamqp.create_message() # if body_type is not given, we detect the body type by checking the type of the object if not body_type: self._auto_set_body(body) else: self._set_body_by_body_type(body, body_type) if msg_format: self._message.message_format = msg_format self._properties = properties self._application_properties = application_properties self._annotations = annotations self._delivery_annotations = delivery_annotations self._header = header self._footer = footer def __getstate__(self): state = self.__dict__.copy() state["state"] = self.state.value state["_message"] = None state["_body_type"] = self._body.type.value if self._body else None if isinstance(self._body, (DataBody, SequenceBody)): state["_body"] = list(self._body.data) elif isinstance(self._body, ValueBody): state["_body"] = self._body.data return state def __setstate__(self, state): state["state"] = constants.MessageState(state.get("state")) self.__dict__.update(state) body = state.get("_body") body_type = constants.BODY_TYPE_C_PYTHON_MAP.get(state.get("_body_type")) self._message = c_uamqp.create_message() if body: if not body_type: self._auto_set_body(body) else: self._set_body_by_body_type(body, body_type) @property def properties(self): if self._need_further_parse: self._parse_message_properties() return self._properties @properties.setter def properties(self, value): if value and not isinstance(value, MessageProperties): raise TypeError("Properties must be a MessageProperties.") self._properties = value @property def header(self): if self._need_further_parse: self._parse_message_properties() return self._header @header.setter def header(self, value): if value and not isinstance(value, MessageHeader): raise TypeError("Header must be a MessageHeader.") self._header = value @property def footer(self): if self._need_further_parse: self._parse_message_properties() return self._footer @footer.setter def footer(self, value): if value and not isinstance(value, dict): raise TypeError("Footer must be a dictionary") footer_props = c_uamqp.create_footer( utils.data_factory(value, encoding=self._encoding) ) self._message.footer = footer_props self._footer = value @property def application_properties(self): if self._need_further_parse: self._parse_message_properties() return self._application_properties @application_properties.setter def application_properties(self, value): if value and not isinstance(value, dict): raise TypeError("Application properties must be a dictionary.") self._application_properties = value @property def annotations(self): if self._need_further_parse: self._parse_message_properties() return self._annotations @annotations.setter def annotations(self, value): if value and not isinstance(value, dict): raise TypeError("Message annotations must be a dictionary.") self._annotations = value @property def message_annotations(self): return self.annotations @property def delivery_annotations(self): if self._need_further_parse: self._parse_message_properties() return self._delivery_annotations @delivery_annotations.setter def delivery_annotations(self, value): self._delivery_annotations = value @property def data(self): if not self._message or not self._body: return None # pylint: disable=protected-access if self._body.type == c_uamqp.MessageBodyType.DataType: return self._body.data return None @property def sequence(self): try: if not self._message or not self._body: return None except AttributeError: return None # pylint: disable=protected-access if self._body.type == c_uamqp.MessageBodyType.SequenceType: return self._body.data return None @property def value(self): try: if not self._message or not self._body: return None except AttributeError: return None # pylint: disable=protected-access if self._body.type == c_uamqp.MessageBodyType.ValueType: return self._body.data return None @classmethod def decode_from_bytes(cls, data): """Decode an AMQP message from a bytearray. The returned message will not have a delivery context and therefore will be considered to be in an "already settled" state. :param data: The AMQP wire-encoded bytes to decode. :type data: bytes or bytearray """ decoded_message = c_uamqp.decode_message(len(data), data) return cls(message=decoded_message) def __str__(self): if not self._message: return "" return str(self._body) def _parse_message_properties(self): if self._need_further_parse: _props = self._message.properties if _props: _logger.debug( "Parsing received message properties %r.", self.delivery_no ) self._properties = MessageProperties( properties=_props, encoding=self._encoding ) _header = self._message.header if _header: _logger.debug("Parsing received message header %r.", self.delivery_no) self._header = MessageHeader(header=_header) _footer = self._message.footer if _footer: _logger.debug("Parsing received message footer %r.", self.delivery_no) self._footer = _footer.map _app_props = self._message.application_properties if _app_props: _logger.debug( "Parsing received message application properties %r.", self.delivery_no, ) self._application_properties = _app_props.map _ann = self._message.message_annotations if _ann: _logger.debug( "Parsing received message annotations %r.", self.delivery_no ) self._annotations = _ann.map _delivery_ann = self._message.delivery_annotations if _delivery_ann: _logger.debug( "Parsing received message delivery annotations %r.", self.delivery_no, ) self._delivery_annotations = _delivery_ann.map self._need_further_parse = False def _parse_message_body(self, message): """Parse a message received from an AMQP service. :param message: The received C message. :type message: uamqp.c_uamqp.cMessage """ _logger.debug("Parsing received message %r.", self.delivery_no) self._message = message delivery_tag = self._message.delivery_tag if delivery_tag: self.delivery_tag = delivery_tag.value body_type = message.body_type if body_type == c_uamqp.MessageBodyType.NoneType: self._body = None elif body_type == c_uamqp.MessageBodyType.DataType: self._body = DataBody(self._message) elif body_type == c_uamqp.MessageBodyType.SequenceType: self._body = SequenceBody(self._message) else: self._body = ValueBody(self._message) self._need_further_parse = True def _can_settle_message(self): if self.state not in constants.RECEIVE_STATES: raise TypeError("Only received messages can be settled.") if self.settled: return False return True def _auto_set_body(self, body): """ Automatically detect the MessageBodyType and set data when no body type information is provided. We categorize object of type list/list of lists into ValueType (not into SequenceType) due to compatibility with old uamqp version. """ if isinstance(body, (str, bytes)): self._body = DataBody(self._message) self._body.append(body) elif isinstance(body, list) and all([isinstance(b, (str, bytes)) for b in body]): self._body = DataBody(self._message) for value in body: self._body.append(value) else: self._body = ValueBody(self._message) self._body.set(body) def _set_body_by_body_type(self, body, body_type): if body_type == constants.MessageBodyType.Data: self._body = DataBody(self._message) if isinstance(body, (str, bytes)): self._body.append(body) elif isinstance(body, list) and all([isinstance(b, (str, bytes)) for b in body]): for value in body: self._body.append(value) else: raise TypeError( "For MessageBodyType.Data, the body" " must be str or bytes or list of str or bytes.") elif body_type == constants.MessageBodyType.Sequence: self._body = SequenceBody(self._message) if isinstance(body, list) and all([isinstance(b, list) for b in body]): for value in body: self._body.append(value) elif isinstance(body, list): self._body.append(body) else: raise TypeError( "For MessageBodyType.Sequence, the body" " must be list or list of lists.") elif body_type == constants.MessageBodyType.Value: self._body = ValueBody(self._message) self._body.set(body) else: raise ValueError("Unsupported MessageBodyType: {}".format(body_type)) def _populate_message_attributes(self, c_message): if self.properties: c_message.properties = self.properties.get_properties_obj() if self.application_properties: if not isinstance(self.application_properties, dict): raise TypeError("Application properties must be a dictionary.") amqp_props = utils.data_factory( self.application_properties, encoding=self._encoding ) c_message.application_properties = amqp_props if self.annotations: if not isinstance(self.annotations, dict): raise TypeError("Message annotations must be a dictionary.") ann_props = c_uamqp.create_message_annotations( utils.data_factory(self.annotations, encoding=self._encoding) ) c_message.message_annotations = ann_props if self.delivery_annotations: if not isinstance(self.delivery_annotations, dict): raise TypeError("Delivery annotations must be a dictionary.") delivery_ann_props = c_uamqp.create_delivery_annotations( utils.data_factory(self.delivery_annotations, encoding=self._encoding) ) c_message.delivery_annotations = delivery_ann_props if self.header: c_message.header = self.header.get_header_obj() if self.footer: if not isinstance(self.footer, dict): raise TypeError("Footer must be a dictionary.") footer = c_uamqp.create_footer( utils.data_factory(self.footer, encoding=self._encoding) ) c_message.footer = footer @property def settled(self): """Whether the message transaction for this message has been completed. If this message is to be sent, the message will be `settled=True` once a disposition has been received from the service. If this message has been received, the message will be `settled=True` once a disposition has been sent to the service. :rtype: bool """ if self._response: return True return False def get_message_encoded_size(self): """Pre-emptively get the size of the message once it has been encoded to go over the wire so we can raise an error if the message will be rejected for being to large. This method is not available for messages that have been received. :rtype: int """ if not self._message: raise ValueError("No message data to encode.") cloned_data = self._message.clone() self._populate_message_attributes(cloned_data) encoded_data = [] return c_uamqp.get_encoded_message_size(cloned_data, encoded_data) def encode_message(self): """Encode message to AMQP wire-encoded bytearray. :rtype: bytearray """ if not self._message: raise ValueError("No message data to encode.") cloned_data = self._message.clone() self._populate_message_attributes(cloned_data) encoded_data = [] c_uamqp.get_encoded_message_size(cloned_data, encoded_data) return b"".join(encoded_data) def get_data(self): """Get the body data of the message. The format may vary depending on the body type. :rtype: generator """ if not self._message or not self._body: return None return self._body.data def gather(self): """Return all the messages represented by this object. This will always be a list of a single message. :rtype: list[~uamqp.message.Message] """ if self.state in constants.RECEIVE_STATES: raise TypeError("Only new messages can be gathered.") if not self._message: raise ValueError("Message data already consumed.") try: raise self._response except TypeError: pass return [self] def get_message(self): """Get the underlying C message from this object. :rtype: uamqp.c_uamqp.cMessage """ if not self._message: return None self._populate_message_attributes(self._message) return self._message def accept(self): """Send a response disposition to the service to indicate that a received message has been accepted. If the client is running in PeekLock mode, the service will wait on this disposition. Otherwise it will be ignored. Returns `True` is message was accepted, or `False` if the message was already settled. :rtype: bool :raises: TypeError if the message is being sent rather than received. """ if self._can_settle_message(): self._response = errors.MessageAccepted() self._settler(self._response) self.state = constants.MessageState.ReceivedSettled return True return False def reject(self, condition=None, description=None, info=None): """Send a response disposition to the service to indicate that a received message has been rejected. If the client is running in PeekLock mode, the service will wait on this disposition. Otherwise it will be ignored. A rejected message will increment the messages delivery count. Returns `True` is message was rejected, or `False` if the message was already settled. :param condition: The AMQP rejection code. By default this is `amqp:internal-error`. :type condition: bytes or str :param description: A description/reason to accompany the rejection. :type description: bytes or str :param info: Information about the error condition. :type info: dict :rtype: bool :raises: TypeError if the message is being sent rather than received. """ if self._can_settle_message(): self._response = errors.MessageRejected( condition=condition, description=description, info=info, encoding=self._encoding, ) self._settler(self._response) self.state = constants.MessageState.ReceivedSettled return True return False def release(self): """Send a response disposition to the service to indicate that a received message has been released. If the client is running in PeekLock mode, the service will wait on this disposition. Otherwise it will be ignored. A released message will not incremenet the messages delivery count. Returns `True` is message was released, or `False` if the message was already settled. :rtype: bool :raises: TypeError if the message is being sent rather than received. """ if self._can_settle_message(): self._response = errors.MessageReleased() self._settler(self._response) self.state = constants.MessageState.ReceivedSettled return True return False def modify(self, failed, deliverable, annotations=None): """Send a response disposition to the service to indicate that a received message has been modified. If the client is running in PeekLock mode, the service will wait on this disposition. Otherwise it will be ignored. Returns `True` is message was modified, or `False` if the message was already settled. :param failed: Whether this delivery of this message failed. This does not indicate whether subsequence deliveries of this message would also fail. :type failed: bool :param deliverable: Whether this message will be deliverable to this client on subsequent deliveries - i.e. whether delivery is retryable. :type deliverable: bool :param annotations: Annotations to attach to response. :type annotations: dict :rtype: bool :raises: TypeError if the message is being sent rather than received. """ if self._can_settle_message(): self._response = errors.MessageModified( failed, deliverable, annotations=annotations, encoding=self._encoding ) self._settler(self._response) self.state = constants.MessageState.ReceivedSettled return True return False class BatchMessage(Message): """A Batched AMQP message. This batch message encodes multiple message bodies into a single message to increase through-put over the wire. It requires server-side support to unpackage the batched messages and so will not be universally supported. :ivar on_send_complete: A custom callback to be run on completion of the send operation of this message. The callback must take two parameters, a result (of type ~uamqp.constants.MessageSendResult) and an error (of type Exception). The error parameter may be None if no error ocurred or the error information was undetermined. :vartype on_send_complete: callable[~uamqp.constants.MessageSendResult, Exception] :ivar batch_format: The is the specific message format to inform the service the the body should be interpreted as multiple messages. The value is 0x80013700. :vartype batch_format: int :ivar max_message_length: The maximum data size in bytes to allow in a single message. By default this is 256kb. If sending a single batch message, an error will be raised if the supplied data exceeds this maximum. If sending multiple batch messages, this value will be used to divide the supplied data between messages. :vartype max_message_length: int :param data: An iterable source of data, where each value will be considered the body of a single message in the batch. :type data: iterable :param properties: Properties to add to the message. If multiple messages are created these properties will be applied to each message. :type properties: ~uamqp.message.MessageProperties :param application_properties: Service specific application properties. If multiple messages are created these properties will be applied to each message. :type application_properties: dict :param annotations: Service specific message annotations. If multiple messages are created these properties will be applied to each message. Keys in the dictionary must be `types.AMQPSymbol` or `types.AMQPuLong`. :type annotations: dict :param header: The message header. This header will be applied to each message in the batch. :type header: ~uamqp.message.MessageHeader :param multi_messages: Whether to send the supplied data across multiple messages. If set to `False`, all the data will be sent in a single message, and an error raised if the message is too large. If set to `True`, the data will automatically be divided across multiple messages of an appropriate size. The default is `False`. :type multi_messages: bool :param encoding: The encoding to use for parameters supplied as strings. Default is 'UTF-8' :type encoding: str :raises: ValueError if data is sent in a single message and that message exceeds the max size. """ batch_format = 0x80013700 max_message_length = constants.MAX_MESSAGE_LENGTH_BYTES size_offset = 0 def __init__( self, data=None, properties=None, application_properties=None, annotations=None, header=None, multi_messages=False, encoding="UTF-8", ): # pylint: disable=super-init-not-called self._multi_messages = multi_messages self._body_gen = data self._encoding = encoding self.on_send_complete = None self._properties = properties self._application_properties = application_properties self._annotations = annotations self._header = header self._need_further_parse = False def __getstate__(self): state = self.__dict__.copy() return state def __setstate__(self, state): self.__dict__.update(state) def _create_batch_message(self): """Create a ~uamqp.message.Message for a value supplied by the data generator. Applies all properties and annotations to the message. :rtype: ~uamqp.message.Message """ return Message( body=[], properties=self.properties, annotations=self.annotations, msg_format=self.batch_format, header=self.header, encoding=self._encoding, ) def _multi_message_generator(self): """Generate multiple ~uamqp.message.Message objects from a single data stream that in total may exceed the maximum individual message size. Data will be continuously added to a single message until that message reaches a max allowable size, at which point it will be yielded and a new message will be started. :rtype: generator[~uamqp.message.Message] """ unappended_message_bytes = None while True: new_message = self._create_batch_message() message_size = new_message.get_message_encoded_size() + self.size_offset body_size = 0 if unappended_message_bytes: new_message._body.append( # pylint: disable=protected-access unappended_message_bytes ) body_size += len(unappended_message_bytes) try: for data in self._body_gen: message_bytes = None try: # try to get the internal uamqp Message internal_uamqp_message = data.message except AttributeError: # no inernal message, data could be uamqp Message or raw data internal_uamqp_message = data try: # uamqp Message if ( not internal_uamqp_message.application_properties and self.application_properties ): internal_uamqp_message.application_properties = ( self.application_properties ) message_bytes = internal_uamqp_message.encode_message() except AttributeError: # raw data wrap_message = Message( body=internal_uamqp_message, application_properties=self.application_properties, ) message_bytes = wrap_message.encode_message() body_size += len(message_bytes) if (body_size + message_size) > self.max_message_length: new_message.on_send_complete = self.on_send_complete unappended_message_bytes = message_bytes yield new_message raise StopIteration() new_message._body.append( # pylint: disable=protected-access message_bytes ) except StopIteration: _logger.debug("Sent partial message.") continue else: new_message.on_send_complete = self.on_send_complete yield new_message _logger.debug("Sent all batched data.") break @property def data(self): """Returns an iterable source of data, where each value will be considered the body of a single message in the batch. :rtype: iterable """ return self._body_gen def gather(self): """Return all the messages represented by this object. This will convert the batch data into individual Message objects, which may be one or more if multi_messages is set to `True`. :rtype: list[~uamqp.message.Message] """ if self._multi_messages: return self._multi_message_generator() new_message = self._create_batch_message() message_size = new_message.get_message_encoded_size() + self.size_offset body_size = 0 for data in self._body_gen: message_bytes = None try: # try to get the internal uamqp Message internal_uamqp_message = data.message except AttributeError: # no inernal message, data could be uamqp Message or raw data internal_uamqp_message = data try: # uamqp Message if ( not internal_uamqp_message.application_properties and self.application_properties ): internal_uamqp_message.application_properties = ( self.application_properties ) message_bytes = internal_uamqp_message.encode_message() except AttributeError: # raw data wrap_message = Message( body=internal_uamqp_message, application_properties=self.application_properties, ) message_bytes = wrap_message.encode_message() body_size += len(message_bytes) if (body_size + message_size) > self.max_message_length: raise errors.MessageContentTooLarge() new_message._body.append(message_bytes) # pylint: disable=protected-access new_message.on_send_complete = self.on_send_complete return [new_message] class MessageProperties(object): """Message properties. The properties that are actually used will depend on the service implementation. Not all received messages will have all properties, and not all properties will be utilized on a sent message. :ivar message_id: Message-id, if set, uniquely identifies a message within the message system. The message producer is usually responsible for setting the message-id in such a way that it is assured to be globally unique. A broker MAY discard a message as a duplicate if the value of the message-id matches that of a previously received message sent to the same node. :vartype message_id: str or bytes or uuid.UUID or ~uamqp.types.AMQPType :ivar user_id: The identity of the user responsible for producing the message. The client sets this value, and it MAY be authenticated by intermediaries. :vartype user_id: str or bytes :ivar to: The to field identifies the node that is the intended destination of the message. On any given transfer this might not be the node at the receiving end of the link. :vartype to: str or bytes :ivar subject: :vartype subject: :ivar reply_to: :vartype reply_to: :ivar correlation_id: :vartype correlation_id: :ivar content_type: :vartype content_type: :ivar content_encoding: :vartype content_encoding: :ivar absolute_expiry_time: :vartype absolute_expiry_time: :ivar creation_time: :vartype creation_time: :ivar group_id: :vartype group_id: :ivar group_sequence: :vartype group_sequence: :ivar reply_to_group_id: :vartype reply_to_group_id: """ def __init__( self, message_id=None, user_id=None, to=None, subject=None, reply_to=None, correlation_id=None, content_type=None, content_encoding=None, absolute_expiry_time=None, creation_time=None, group_id=None, group_sequence=None, reply_to_group_id=None, properties=None, encoding="UTF-8", ): self._encoding = encoding if properties: self._message_id = properties.message_id self._user_id = properties.user_id self._to = properties.to self._subject = properties.subject self._reply_to = properties.reply_to self._correlation_id = properties.correlation_id self._content_type = properties.content_type self._content_encoding = properties.content_encoding self._absolute_expiry_time = properties.absolute_expiry_time self._creation_time = properties.creation_time self._group_id = properties.group_id self._group_sequence = properties.group_sequence self._reply_to_group_id = properties.reply_to_group_id else: self.message_id = message_id self.user_id = user_id self.to = to self.subject = subject self.reply_to = reply_to self.correlation_id = correlation_id self.content_type = content_type self.content_encoding = content_encoding self.absolute_expiry_time = absolute_expiry_time self.creation_time = creation_time self.group_id = group_id self.group_sequence = group_sequence self.reply_to_group_id = reply_to_group_id def __str__(self): return str( { "message_id": self.message_id, "user_id": self.user_id, "to": self.to, "subject": self.subject, "reply_to": self.reply_to, "correlation_id": self.correlation_id, "content_type": self.content_type, "content_encoding": self.content_encoding, "absolute_expiry_time": self.absolute_expiry_time, "creation_time": self.creation_time, "group_id": self.group_id, "group_sequence": self.group_sequence, "reply_to_group_id": self.reply_to_group_id, } ) def __getstate__(self): state = self._get_properties_dict() state["_encoding"] = self._encoding return state def __setstate__(self, state): self._encoding = state.pop("_encoding") for key, val in state.items(): self.__setattr__(key, val) @property def message_id(self): if self._message_id: return self._message_id.value return None @message_id.setter def message_id(self, value): if value is None: self._message_id = None else: self._message_id = utils.data_factory(value, encoding=self._encoding) @property def user_id(self): try: if self._user_id is not None: return self._user_id.value return None except AttributeError: return self._user_id @user_id.setter def user_id(self, value): if isinstance(value, str): value = value.encode(self._encoding) elif value is not None and not isinstance(value, bytes): raise TypeError("user_id must be bytes or str.") # user_id is type of binary according to the spec. # convert byte string into bytearray then wrap the data into c_uamqp.BinaryValue. if value is not None: self._user_id = utils.data_factory( bytearray(value), encoding=self._encoding ) else: self._user_id = None @property def to(self): if self._to: return self._to.value return None @to.setter def to(self, value): if value is None: self._to = None else: self._to = utils.data_factory(value, encoding=self._encoding) @property def subject(self): return self._subject @subject.setter def subject(self, value): if isinstance(value, str): value = value.encode(self._encoding) elif value is not None and not isinstance(value, bytes): raise TypeError("subject must be bytes or str.") self._subject = value @property def reply_to(self): if self._reply_to is not None: return self._reply_to.value return None @reply_to.setter def reply_to(self, value): if value is None: self._reply_to = None else: self._reply_to = utils.data_factory(value, encoding=self._encoding) @property def correlation_id(self): if self._correlation_id is not None: return self._correlation_id.value return None @correlation_id.setter def correlation_id(self, value): if value is None: self._correlation_id = None else: self._correlation_id = utils.data_factory(value, encoding=self._encoding) @property def content_type(self): return self._content_type @content_type.setter def content_type(self, value): if isinstance(value, str): value = value.encode(self._encoding) elif value is not None and not isinstance(value, bytes): raise TypeError("content_type must be bytes or str.") self._content_type = value @property def content_encoding(self): return self._content_encoding @content_encoding.setter def content_encoding(self, value): if isinstance(value, str): value = value.encode(self._encoding) elif value is not None and not isinstance(value, bytes): raise TypeError("content_encoding must be bytes or str.") self._content_encoding = value @property def absolute_expiry_time(self): return self._absolute_expiry_time @absolute_expiry_time.setter def absolute_expiry_time(self, value): if value is not None and not isinstance(value, int): raise TypeError("absolute_expiry_time must be an integer.") self._absolute_expiry_time = value @property def creation_time(self): return self._creation_time @creation_time.setter def creation_time(self, value): if value is not None and not isinstance(value, int): raise TypeError("creation_time must be an integer.") self._creation_time = value @property def group_id(self): return self._group_id @group_id.setter def group_id(self, value): if isinstance(value, str): value = value.encode(self._encoding) elif value is not None and not isinstance(value, bytes): raise TypeError("group_id must be bytes or str.") self._group_id = value @property def group_sequence(self): return self._group_sequence @group_sequence.setter def group_sequence(self, value): if value is not None and not isinstance(value, int): raise TypeError("group_sequence must be an integer.") self._group_sequence = value @property def reply_to_group_id(self): return self._reply_to_group_id @reply_to_group_id.setter def reply_to_group_id(self, value): if isinstance(value, str): value = value.encode(self._encoding) elif value is not None and not isinstance(value, bytes): raise TypeError("reply_to_group_id must be bytes or str.") self._reply_to_group_id = value def _set_attr(self, attr, properties): attr_value = getattr(self, "_" + attr) if attr_value is not None: setattr(properties, attr, attr_value) def _get_properties_dict(self): return { "message_id": self.message_id, "user_id": self.user_id, "to": self.to, "subject": self.subject, "reply_to": self.reply_to, "correlation_id": self.correlation_id, "content_type": self.content_type, "content_encoding": self.content_encoding, "absolute_expiry_time": self.absolute_expiry_time, "creation_time": self.creation_time, "group_id": self.group_id, "group_sequence": self.group_sequence, "reply_to_group_id": self.reply_to_group_id, } def get_properties_obj(self): """Get the underlying C reference from this object. :rtype: uamqp.c_uamqp.cProperties """ properties = c_uamqp.cProperties() self._set_attr("message_id", properties) self._set_attr("user_id", properties) self._set_attr("to", properties) self._set_attr("subject", properties) self._set_attr("reply_to", properties) self._set_attr("correlation_id", properties) self._set_attr("content_type", properties) self._set_attr("content_encoding", properties) self._set_attr("absolute_expiry_time", properties) self._set_attr("creation_time", properties) self._set_attr("group_id", properties) self._set_attr("group_sequence", properties) self._set_attr("reply_to_group_id", properties) return properties class MessageBody(object): """Base class for an AMQP message body. This should not be used directly. """ def __init__(self, c_message, encoding="UTF-8"): self._message = c_message self._encoding = encoding @property def type(self): return self._message.body_type @property def data(self): raise NotImplementedError("Only MessageBody subclasses have data.") class DataBody(MessageBody): """An AMQP message body of type Data. This represents a list of bytes sections. :ivar type: The body type. This should always be `DataType`. :vartype type: uamqp.c_uamqp.MessageBodyType :ivar data: The data contained in the message body. This returns a generator to iterate over each section in the body, where each section will be a byte string. :vartype data: Generator[bytes] """ def __str__(self): return "".join(d.decode(self._encoding) for d in self.data) def __unicode__(self): return u"".join(d.decode(self._encoding) for d in self.data) def __bytes__(self): return b"".join(self.data) def __len__(self): return self._message.count_body_data() def __getitem__(self, index): if index >= len(self): raise IndexError("Index is out of range.") data = self._message.get_body_data(index) return data.value def append(self, data): """Append a section to the body. :param data: The data to append. :type data: str or bytes """ if isinstance(data, str): self._message.add_body_data(data.encode(self._encoding)) elif isinstance(data, bytes): self._message.add_body_data(data) @property def data(self): for i in range(len(self)): yield self._message.get_body_data(i) class ValueBody(MessageBody): """An AMQP message body of type Value. This represents a single encoded object. :ivar type: The body type. This should always be ValueType :vartype type: uamqp.c_uamqp.MessageBodyType :ivar data: The data contained in the message body. The value of the encoded object :vartype data: object """ def __str__(self): data = self.data if not data: return "" if isinstance(data, bytes): return data.decode(self._encoding) return str(data) def __unicode__(self): data = self.data if not data: return u"" if isinstance(data, bytes): return data.decode(self._encoding) return unicode(data) # pylint: disable=undefined-variable def __bytes__(self): data = self.data if not data: return b"" return bytes(data) def set(self, value): """Set a value as the message body. This can be any Python data type and it will be automatically encoded into an AMQP type. If a specific AMQP type is required, a `types.AMQPType` can be used. :param data: The data to send in the body. :type data: ~uamqp.types.AMQPType """ value = utils.data_factory(value) self._message.set_body_value(value) @property def data(self): _value = self._message.get_body_value() if _value: return _value.value return None class SequenceBody(MessageBody): """An AMQP message body of type Sequence. This represents a list of sequence sections. :ivar type: The body type. This should always be SequenceType :vartype type: uamqp.c_uamqp.MessageBodyType :ivar data: The data contained in the message body. This returns a generator to iterate over each section in the body, where each section will be a list of objects. :vartype data: Generator[List[object]] """ def __str__(self): output_str = "" for sequence_section in self.data: for d in sequence_section: if isinstance(d, bytes): output_str += d.decode(self._encoding) else: output_str += str(d) return output_str def __unicode__(self): output_unicode = u"" for sequence_section in self.data: for d in sequence_section: if isinstance(d, bytes): output_unicode += d.decode(self._encoding) else: output_unicode += unicode(d) # pylint: disable=undefined-variable return output_unicode def __bytes__(self): return b"".join(bytes(d) for sequence_section in self.data for d in sequence_section) def __len__(self): return self._message.count_body_sequence() def __getitem__(self, index): if index >= len(self): raise IndexError("Index is out of range.") data = self._message.get_body_sequence(index) return data.value def append(self, data): """Append a sequence section to the body. The data should be a list of objects. The object in the list can be any Python data type and it will be automatically encoded into an AMQP type. If a specific AMQP type is required, a `types.AMQPType` can be used. :param data: The list of objects to append. :type data: list[~uamqp.types.AMQPType] """ data = utils.data_factory(data) self._message.add_body_sequence(data) @property def data(self): for i in range(len(self)): yield self._message.get_body_sequence(i).value class MessageHeader(object): """The Message header. This is only used on received message, and not set on messages being sent. The properties set on any given message will depend on the Service and not all messages will have all properties. :ivar delivery_count: The number of unsuccessful previous attempts to deliver this message. If this value is non-zero it can be taken as an indication that the delivery might be a duplicate. On first delivery, the value is zero. It is incremented upon an outcome being settled at the sender, according to rules defined for each outcome. :vartype delivery_count: int :ivar time_to_live: Duration in milliseconds for which the message is to be considered "live". If this is set then a message expiration time will be computed based on the time of arrival at an intermediary. Messages that live longer than their expiration time will be discarded (or dead lettered). When a message is transmitted by an intermediary that was received with a ttl, the transmitted message's header SHOULD contain a ttl that is computed as the difference between the current time and the formerly computed message expiration time, i.e., the reduced ttl, so that messages will eventually die if they end up in a delivery loop. :vartype time_to_live: int :ivar durable: Durable messages MUST NOT be lost even if an intermediary is unexpectedly terminated and restarted. A target which is not capable of fulfilling this guarantee MUST NOT accept messages where the durable header is set to `True`: if the source allows the rejected outcome then the message SHOULD be rejected with the precondition-failed error, otherwise the link MUST be detached by the receiver with the same error. :vartype durable: bool :ivar first_acquirer: If this value is `True`, then this message has not been acquired by any other link. If this value is `False`, then this message MAY have previously been acquired by another link or links. :vartype first_acquirer: bool :ivar priority: This field contains the relative message priority. Higher numbers indicate higher priority messages. Messages with higher priorities MAY be delivered before those with lower priorities. :vartype priority: int :param header: Internal only. This is used to wrap an existing message header that has been received from an AMQP service. :type header: uamqp.c_uamqp.cHeader """ def __init__(self, header=None): self.delivery_count = 0 self.time_to_live = None self.first_acquirer = None self.durable = None self.priority = None if header: self.delivery_count = header.delivery_count or 0 self.time_to_live = header.time_to_live self.first_acquirer = header.first_acquirer self.durable = header.durable self.priority = header.priority def __str__(self): return str( { "delivery_count": self.delivery_count, "time_to_live": self.time_to_live, "first_acquirer": self.first_acquirer, "durable": self.durable, "priority": self.priority, } ) @property def ttl(self): """ Alias for time_to_live. :rtype: int """ return self.time_to_live def get_header_obj(self): """Get the underlying C reference from this object. :rtype: uamqp.c_uamqp.cHeader """ header = c_uamqp.create_header() header.delivery_count = self.delivery_count or 0 if self.time_to_live is not None: header.time_to_live = self.time_to_live if self.first_acquirer is not None: header.first_acquirer = self.first_acquirer if self.durable is not None: header.durable = self.durable if self.priority is not None: header.priority = self.priority return header