def _build_message(self, body): if isinstance(body, list) and body: # TODO: This only works for a list of bytes/strings self.message = uamqp.Message(body[0], properties=self.properties, header=self.header) for more in body[1:]: self.message._body.append(more) # pylint: disable=protected-access elif body is None: raise ValueError("Message body cannot be None.") else: self.message = uamqp.Message(body, properties=self.properties, header=self.header)
async def test_event_hubs_async_sender_sync(live_eventhub_config): annotations={b"x-opt-partition-key": b"PartitionKeyInfo"} msg_content = b"hello world" message = uamqp.Message(msg_content, annotations=annotations) uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAsync.from_shared_access_key(uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = uamqp.SendClientAsync(target, auth=sas_auth, debug=False) for _ in range(10): message = uamqp.Message(msg_content, application_properties=annotations, annotations=annotations) send_client.send_message(message) send_client.close()
def _message_received(self, message): """Callback run on receipt of every message. If there is a user-defined callback, this will be called. Additionally if the client is retrieving messages for a batch or iterator, the message will be added to an internal queue. :param message: c_uamqp.Message """ # pylint: disable=protected-access message_number = self._receiver.last_received_message_number() if self._settle_mode == constants.ReceiverSettleMode.ReceiveAndDelete: settler = None else: settler = functools.partial(self._settle_message, message_number) try: wrapped_message = uamqp.Message( message=message, encoding=self.encoding, settler=settler, delivery_no=message_number) self.on_message_received(wrapped_message) except RuntimeError: condition = b"amqp:unknown-error" self._error = errors._process_link_error(self.error_policy, condition, None, None) _logger.info("Unable to settle message no %r. Disconnecting.\nLink: %r\nConnection: %r", message_number, self.name, self._session._connection.container_id) except KeyboardInterrupt: _logger.error("Received shutdown signal while processing message no %r\nRejecting message.", message_number) self._receiver.settle_modified_message(message_number, True, True, None) self._error = errors.AMQPClientShutdown() except Exception as e: # pylint: disable=broad-except _logger.error("Error processing message no %r: %r\nRejecting message.", message_number, e) self._receiver.settle_modified_message(message_number, True, True, None)
def test_sys_properties(): properties = uamqp.message.MessageProperties() properties.message_id = "message_id" properties.user_id = "user_id" properties.to = "to" properties.subject = "subject" properties.reply_to = "reply_to" properties.correlation_id = "correlation_id" properties.content_type = "content_type" properties.content_encoding = "content_encoding" properties.absolute_expiry_time = 1 properties.creation_time = 1 properties.group_id = "group_id" properties.group_sequence = 1 properties.reply_to_group_id = "reply_to_group_id" message = uamqp.Message(properties=properties) message.annotations = {_common.PROP_OFFSET: "@latest"} ed = EventData._from_message(message) # type: EventData assert ed.system_properties[_common.PROP_OFFSET] == "@latest" assert ed.system_properties[_common.PROP_CORRELATION_ID] == properties.correlation_id assert ed.system_properties[_common.PROP_MESSAGE_ID] == properties.message_id assert ed.system_properties[_common.PROP_CONTENT_ENCODING] == properties.content_encoding assert ed.system_properties[_common.PROP_CONTENT_TYPE] == properties.content_type assert ed.system_properties[_common.PROP_USER_ID] == properties.user_id assert ed.system_properties[_common.PROP_TO] == properties.to assert ed.system_properties[_common.PROP_SUBJECT] == properties.subject assert ed.system_properties[_common.PROP_REPLY_TO] == properties.reply_to assert ed.system_properties[_common.PROP_ABSOLUTE_EXPIRY_TIME] == properties.absolute_expiry_time assert ed.system_properties[_common.PROP_CREATION_TIME] == properties.creation_time assert ed.system_properties[_common.PROP_GROUP_ID] == properties.group_id assert ed.system_properties[_common.PROP_GROUP_SEQUENCE] == properties.group_sequence assert ed.system_properties[_common.PROP_REPLY_TO_GROUP_ID] == properties.reply_to_group_id
async def send_async(): TOPIC_NAME = config['topic_name'] SERVICE_NAMESPACE = config['service_namespace'] KEY_NAME = config['key_name'] KEY_VALUE = config['key_value'] HOSTNAME = '{}.servicebus.windows.net'.format(SERVICE_NAMESPACE) uri = "sb://{}/{}".format(HOSTNAME, TOPIC_NAME) sas_auth = authentication.SASTokenAsync.from_shared_access_key( uri, KEY_NAME, KEY_VALUE) target = "amqps://{}/{}".format(HOSTNAME, TOPIC_NAME) send_client = uamqp.SendClientAsync(target, auth=sas_auth, debug=False) start_time = time.time() count = 0 time_printed = 0 while True: count += 1 end_time = time.time() period = end_time - start_time if time_printed < int(period): time_printed = int(period) rate = count / (end_time - start_time) print("".join([str(count), " messages in ", str(period), " secs ; rate=" + str(rate) + " msgs/sec"])) msg_content = b"hello world" message = uamqp.Message(msg_content) await send_client.send_message_async(message) await send_client.close_async()
def test_event_hubs_client_send_sync(live_eventhub_config): annotations = {b"x-opt-partition-key": b"PartitionKeyInfo"} uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = uamqp.SendClient(target, auth=sas_auth, debug=False) for _ in range(10): header = uamqp.message.MessageHeader() header.durable = True assert header.get_header_obj() props = uamqp.message.MessageProperties(message_id=b"message id", subject="test_subject") assert props.get_properties_obj() msg_content = b"hello world" message = uamqp.Message(msg_content, properties=props, header=header, application_properties=annotations, annotations=annotations) assert message.get_message_encoded_size() == 151 assert message.encode_message( ) == b'\x00Sp\xc0\x06\x05A@@@C\x00Sr\xc1(\x02\xa1\x13x-opt-partition-key\xa1\x10PartitionKeyInfo\x00Ss\xc0\x1d\x04\xa1\nmessage id@@\xa1\x0ctest_subject\x00St\xc1(\x02\xa1\x13x-opt-partition-key\xa1\x10PartitionKeyInfo\x00Su\xa0\x0bhello world' send_client.queue_message(message) results = send_client.send_all_messages(close_on_done=False) assert not [ m for m in results if m == uamqp.constants.MessageState.SendFailed ] send_client.close()
async def _mgmt_request_response( self, mgmt_operation, message, callback, keep_alive_associated_link=True, **kwargs ): await self._open() application_properties = {} # Some mgmt calls do not support an associated link name (such as list_sessions). Most do, so on by default. if keep_alive_associated_link: try: application_properties = {ASSOCIATEDLINKPROPERTYNAME:self._handler.message_handler.name} except AttributeError: pass mgmt_msg = uamqp.Message( body=message, properties=MessageProperties( reply_to=self._mgmt_target, encoding=self._config.encoding, **kwargs), application_properties=application_properties) try: return await self._handler.mgmt_request_async( mgmt_msg, mgmt_operation, op_type=MGMT_REQUEST_OP_TYPE_ENTITY_MGMT, node=self._mgmt_target.encode(self._config.encoding), timeout=5000, callback=callback) except Exception as exp: # pylint: disable=broad-except raise ServiceBusError("Management request failed: {}".format(exp), exp)
def send_c2d_message(target, device_id, data, properties=None, correlation_id=None, ack=None): app_props = {} if properties: app_props.update(properties) app_props['iothub-ack'] = (ack if ack else 'none') msg_props = uamqp.message.MessageProperties() msg_props.to = '/devices/{}/messages/devicebound'.format(device_id) msg_id = str(uuid4()) msg_props.message_id = msg_id if correlation_id: msg_props.correlation_id = correlation_id msg_content = str.encode(data) message = uamqp.Message(msg_content, properties=msg_props, application_properties=app_props) operation = '/messages/devicebound' endpoint = _build_iothub_amqp_endpoint_from_target(target) endpoint = endpoint + operation client = uamqp.SendClient('amqps://' + endpoint, debug=DEBUG) client.queue_message(message) result = client.send_all_messages() errors = [m for m in result if m == uamqp.constants.MessageState.SendFailed] return msg_id, errors
async def _mgmt_request_response( self, mgmt_operation, message, callback, keep_alive_associated_link=True, timeout=None, **kwargs ): # type: (bytes, uamqp.Message, Callable, bool, Optional[float], Any) -> uamqp.Message """ Execute an amqp management operation. :param bytes mgmt_operation: The type of operation to be performed. This value will be service-specific, but common values include READ, CREATE and UPDATE. This value will be added as an application property on the message. :param message: The message to send in the management request. :paramtype message: ~uamqp.message.Message :param callback: The callback which is used to parse the returning message. :paramtype callback: Callable[int, ~uamqp.message.Message, str] :param keep_alive_associated_link: A boolean flag for keeping associated amqp sender/receiver link alive when executing operation on mgmt links. :param timeout: timeout in seconds for executing the mgmt operation. :rtype: None """ await self._open() application_properties = {} # Some mgmt calls do not support an associated link name (such as list_sessions). Most do, so on by default. if keep_alive_associated_link: try: application_properties = { ASSOCIATEDLINKPROPERTYNAME: self._handler.message_handler.name } except AttributeError: pass mgmt_msg = uamqp.Message( body=message, properties=MessageProperties( reply_to=self._mgmt_target, encoding=self._config.encoding, **kwargs ), application_properties=application_properties, ) try: return await self._handler.mgmt_request_async( mgmt_msg, mgmt_operation, op_type=MGMT_REQUEST_OP_TYPE_ENTITY_MGMT, node=self._mgmt_target.encode(self._config.encoding), timeout=timeout * 1000 if timeout else None, callback=callback, ) except Exception as exp: # pylint: disable=broad-except if isinstance(exp, compat.TimeoutException): raise OperationTimeoutError(error=exp) raise
async def send_async(uri, key_name, key_value, target): sas_auth = authentication.SASTokenAsync.from_shared_access_key( uri, key_name, key_value) send_client = uamqp.SendClientAsync(target, auth=sas_auth, debug=False) while True: msg_content = b"hello world" message = uamqp.Message(msg_content) await send_client.send_message_async(message) await send_client.close_async()
async def send_to_device(self, device_id, message): msg_content = json.dumps(message) app_properties = {} msg_props = uamqp.message.MessageProperties() msg_props.to = "/devices/{}/messages/devicebound".format(device_id) msg_props.message_id = str(uuid4()) amqp_message = uamqp.Message( msg_content, properties=msg_props, application_properties=app_properties ) await self.send_client.send_message_async(amqp_message) adapter_config.logger("AMQP service client sent: {}".format(message))
async def test_event_hubs_single_send_async(live_eventhub_config): annotations={b"x-opt-partition-key": b"PartitionKeyInfo"} msg_content = b"hello world" message = uamqp.Message(msg_content, annotations=annotations) uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = a_uamqp.SASTokenAsync.from_shared_access_key(uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = a_uamqp.SendClientAsync(target, auth=sas_auth, debug=False) await send_client.send_message_async(message, close_on_done=True)
async def test_event_hubs_client_send_async(live_eventhub_config): properties = {b"SendData": b"Property_String_Value_1"} msg_content = b"hello world" message = uamqp.Message(msg_content, application_properties=properties) plain_auth = authentication.SASLPlain(live_eventhub_config['hostname'], live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = a_uamqp.SendClientAsync(target, auth=plain_auth, debug=True) send_client.queue_message(message) results = await send_client.send_all_messages_async() assert not [m for m in results if m == uamqp.constants.MessageState.Failed]
def test_rabbitmq_client_send_sync(rabbit_mq_config): pytest.skip("Not working yet") uri = "amqp://{}/{}/".format(rabbit_mq_config['hostname'], rabbit_mq_config['path']) sas_auth = uamqp.authentication.SASLAnonymous(hostname=rabbit_mq_config['hostname'], port=5672) send_client = uamqp.SendClient(uri, auth=sas_auth, debug=True) try: message = uamqp.Message("content") send_client.queue_message(message) results = send_client.send_all_messages(close_on_done=False) assert not [m for m in results if m == uamqp.constants.MessageState.SendFailed] finally: send_client.close()
def test_event_hubs_client_send_multiple_sync(live_eventhub_config): annotations = {b"x-opt-partition-key": b"PartitionKeyInfo"} uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) assert not sas_auth.consumed target = "amqps://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = uamqp.SendClient(target, auth=sas_auth, debug=False) messages = [] for _ in range(10): header = uamqp.message.MessageHeader() header.durable = True header.delivery_count = 5 header.time_to_live = 500000 header.first_acquirer = True header.priority = 3 assert header.get_header_obj() props = uamqp.message.MessageProperties( message_id=b"message id", user_id="user_id", to="to", subject="test", reply_to="reply_to", correlation_id="correlation_id", content_type="content_type", content_encoding="content_encoding", creation_time=12345, absolute_expiry_time=12345, group_id="group_id", group_sequence=1234, reply_to_group_id="reply_to_group_id") assert props.get_properties_obj() msg_content = b"hello world" message = uamqp.Message(msg_content, properties=props, header=header, application_properties=annotations, annotations=annotations) messages.append(message) send_client.queue_message(*messages) assert len(send_client.pending_messages) == 10 results = send_client.send_all_messages() assert len(results) == 10 assert not [ m for m in results if m == uamqp.constants.MessageState.SendFailed ] assert sas_auth.consumed assert send_client.pending_messages == []
def test_event_data_from_message(): message = uamqp.Message('A') event = EventData._from_message(message) assert event.content_type is None assert event.correlation_id is None assert event.message_id is None event.content_type = 'content_type' event.correlation_id = 'correlation_id' event.message_id = 'message_id' assert event.content_type == 'content_type' assert event.correlation_id == 'correlation_id' assert event.message_id == 'message_id'
def send_to_device(self, device_id, message): msg_content = message app_properties = {} msg_props = uamqp.message.MessageProperties() msg_props.to = "/devices/{}/messages/devicebound".format(device_id) msg_props.message_id = str(uuid4()) message = uamqp.Message( msg_content, properties=msg_props, application_properties=app_properties ) self.send_client.queue_message(message) results = self.send_client.send_all_messages() assert not [m for m in results if m == uamqp.constants.MessageState.SendFailed] logger.info("Message sent.")
def _message_received(self, message): """Callback run on receipt of every message. If there is a user-defined callback, this will be called. Additionally if the client is retrieving messages for a batch or iterator, the message will be added to an internal queue. :param message: c_uamqp.Message """ self._was_message_received = True wrapped_message = uamqp.Message(message=message, encoding=self._encoding) if self._message_received_callback: wrapped_message = self._message_received_callback(wrapped_message) or wrapped_message if self._received_messages: self._received_messages.put(wrapped_message)
async def test_event_hubs_mgmt_op_async(live_eventhub_config): plain_auth = authentication.SASLPlain(live_eventhub_config['hostname'], live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) async with uamqp.AMQPClientAsync(target, auth=plain_auth, debug=True) as send_client: mgmt_msg = uamqp.Message(application_properties={'name': live_eventhub_config['event_hub']}) response = await send_client.mgmt_request_async( mgmt_msg, b'READ', op_type=b'com.microsoft:eventhub', status_code_field=b'status-code', description_fields=b'status-description', timeout=3000) output = response.get_data() assert output[b'partition_ids'] == [b"0", b"1"]
def send_to_device(self, device_id, message): msg_content = message app_properties = {} msg_props = uamqp.message.MessageProperties() msg_props.to = "/devices/{}/messages/devicebound".format(device_id) msg_props.message_id = str(uuid4()) message = uamqp.Message(msg_content, properties=msg_props, application_properties=app_properties) self.send_client.queue_message(message) results = self.send_client.send_all_messages(close_on_done=False) assert not [ m for m in results if m == uamqp.constants.MessageState.SendFailed ] adapter_config.logger("AMQP service client sent: {}".format(message))
def test_event_hubs_mgmt_op(live_eventhub_config): uri = "sb://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) sas_auth = authentication.SASTokenAuth.from_shared_access_key( uri, live_eventhub_config['key_name'], live_eventhub_config['access_key']) target = "amqps://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) with uamqp.AMQPClient(target, auth=sas_auth, debug=False) as send_client: mgmt_msg = uamqp.Message(application_properties={'name': live_eventhub_config['event_hub']}) response = send_client.mgmt_request( mgmt_msg, b'READ', op_type=b'com.microsoft:eventhub', status_code_field=b'status-code', description_fields=b'status-description') output = response.get_data() assert output[b'partition_ids'] == [b"0", b"1"]
async def test_iot_hub_send_async(live_iothub_config): msg_content = b"hello world" msg_props = uamqp.message.MessageProperties() msg_props.to = '/devices/{}/messages/devicebound'.format(live_iothub_config['device']) msg_props.message_id = str(uuid4()) message = uamqp.Message(msg_content, properties=msg_props) operation = '/messages/devicebound' endpoint = _build_iothub_amqp_endpoint_from_target(live_iothub_config) target = 'amqps://' + endpoint + operation log.info("Target: {}".format(target)) send_client = uamqp.SendClientAsync(target, debug=False) send_client.queue_message(message) results = await send_client.send_all_messages_async() assert not [m for m in results if m == uamqp.constants.MessageState.SendFailed]
async def test_event_hubs_client_send_multiple_async(live_eventhub_config): properties = {b"SendData": b"Property_String_Value_1"} msg_content = b"hello world" plain_auth = authentication.SASLPlain(live_eventhub_config['hostname'], live_eventhub_config['key_name'], live_eventhub_config['access_key']) assert not plain_auth.consumed target = "amqps://{}/{}".format(live_eventhub_config['hostname'], live_eventhub_config['event_hub']) send_client = uamqp.SendClientAsync(target, auth=plain_auth, debug=False) messages = [] for i in range(10): messages.append(uamqp.Message(msg_content, application_properties=properties)) send_client.queue_message(*messages) assert len(send_client.pending_messages) == 10 results = await send_client.send_all_messages_async() assert len(results) == 10 assert not [m for m in results if m == uamqp.constants.MessageState.SendFailed] assert plain_auth.consumed assert send_client.pending_messages == []
def run(self): while self.running: if not self.use_batch: msg_content = b"Hello world" msg = uamqp.Message(msg_content) self.send_client.queue_message(msg) results = self.send_client.send_all_messages( close_on_done=False) assert not [m for m in results if ( m == uamqp.constants.MessageState.SendFailed)] self.rate.increment() else: message_batch = uamqp.message.BatchMessage( self.data_generator()) self.send_client.queue_message(message_batch) results = self.send_client.send_all_messages( close_on_done=False) assert not [m for m in results if ( m == uamqp.constants.MessageState.SendFailed)]
async def query_meta_data(endpoint, path, auth): source = uamqp.address.Source(endpoint) receive_client = uamqp.ReceiveClientAsync(source, auth=auth, timeout=30000, debug=DEBUG) try: await receive_client.open_async() message = uamqp.Message(application_properties={'name': path}) response = await receive_client.mgmt_request_async( message, b'READ', op_type=b'com.microsoft:eventhub', status_code_field=b'status-code', description_fields=b'status-description', timeout=30000 ) test = response.get_data() return test finally: await receive_client.close_async()
def test_iot_hub_send(live_iothub_config): msg_content = b"hello world" app_properties = {"test_prop_1": "value", "test_prop_2": "X"} msg_props = uamqp.message.MessageProperties() msg_props.to = '/devices/{}/messages/devicebound'.format(live_iothub_config['device']) msg_props.message_id = str(uuid4()) message = uamqp.Message(msg_content, properties=msg_props, application_properties=app_properties) operation = '/messages/devicebound' endpoint = _build_iothub_amqp_endpoint_from_target(live_iothub_config) target = 'amqps://' + endpoint + operation log.info("Target: {}".format(target)) send_client = uamqp.SendClient(target, debug=True) send_client.queue_message(message) results = send_client.send_all_messages() assert not [m for m in results if m == uamqp.constants.MessageState.SendFailed] log.info("Message sent.")
def send_message_to_device(self, device_id, message): """Send a message to the specified deivce. :param str device_id: The name (Id) of the device. :param str message: The message that is to be delivered to the device. :raises: Exception if the Send command is not able to send the message """ msg_content = message app_properties = {} msg_props = uamqp.message.MessageProperties() msg_props.to = "/devices/{}/messages/devicebound".format(device_id) msg_props.message_id = str(uuid4()) message = uamqp.Message(msg_content, properties=msg_props, application_properties=app_properties) self.amqp_client.queue_message(message) results = self.amqp_client.send_all_messages(close_on_done=False) if uamqp.constants.MessageState.SendFailed in results: raise Exception("C2D message sned failure")
def send_message_to_device(self, device_id, message, app_props): """Send a message to the specified deivce. :param str device_id: The name (Id) of the device. :param str message: The message that is to be delivered to the device. :param dict app_props: Application and system properties for the message :raises: Exception if the Send command is not able to send the message """ msg_content = message msg_props = uamqp.message.MessageProperties() msg_props.message_id = str(uuid4()) msg_props.to = "/devices/{}/messages/devicebound".format(device_id) app_properties = {} # loop through all properties and pull out the custom # properties for prop_key, prop_value in app_props.items(): if prop_key == "contentType": msg_props.content_type = prop_value elif prop_key == "contentEncoding": msg_props.content_encoding = prop_value elif prop_key == "correlationId": msg_props.correlation_id = prop_value elif prop_key == "expiryTimeUtc": msg_props.absolute_expiry_time = prop_value elif prop_key == "messageId": msg_props.message_id = prop_value elif prop_key == "userId": msg_props.user_id = prop_value else: app_properties[prop_key] = prop_value message = uamqp.Message(msg_content, properties=msg_props, application_properties=app_properties) self.amqp_client.queue_message(message) results = self.amqp_client.send_all_messages(close_on_done=False) if uamqp.constants.MessageState.SendFailed in results: raise Exception("C2D message send failure")
async def _mgmt_request_response(self, mgmt_operation, message, callback, **kwargs): await self._open() if not self._running: raise InvalidHandlerState("Client connection is closed.") mgmt_msg = uamqp.Message( body=message, properties=MessageProperties( reply_to=self._mgmt_target, encoding=self._config.encoding, **kwargs)) try: return await self._handler.mgmt_request_async( mgmt_msg, mgmt_operation, op_type=MGMT_REQUEST_OP_TYPE_ENTITY_MGMT, node=self._mgmt_target.encode(self._config.encoding), timeout=5000, callback=callback) except Exception as exp: # pylint: disable=broad-except raise ServiceBusError("Management request failed: {}".format(exp), exp)
async def query_meta_data(address, path, auth): source = uamqp.address.Source(address) receive_client = uamqp.ReceiveClientAsync(source, auth=auth, timeout=30000, debug=DEBUG) try: await receive_client.open_async() message = uamqp.Message(application_properties={"name": path}) response = await receive_client.mgmt_request_async( message, b"READ", op_type=b"com.microsoft:eventhub", status_code_field=b"status-code", description_fields=b"status-description", timeout=30000, ) test = response.get_data() return test finally: await receive_client.close_async()