def receive_from_durable_exclusive_queue(messaging_service, topic,
publisher, message):
"""method to receive messages from durable exclusive queue"""
try:
queue_name = constants.QUEUE_NAME_FORMAT.substitute(
iteration=topic_name)
HowToConsumeMessageExclusiveVsSharedMode.create_queue_and_add_topic(
queue_name)
durable_exclusive_queue = Queue.durable_exclusive_queue(
queue_name)
receiver = HowToConsumeMessageExclusiveVsSharedMode \
.create_persistent_message_receiver(messaging_service, durable_exclusive_queue)
message_receiver = BasicTestMessageHandler()
receiver.receive_async(message_receiver)
HowToPublishPersistentMessage.publish_string_message_non_blocking(
publisher, topic, message)
time.sleep(1)
print(
f'Message received count: {message_receiver.total_message_received_count}'
)
finally:
receiver.terminate(0)
HowToConsumeMessageExclusiveVsSharedMode.delete_queue(
queue_name)
def consume_full_message_and_do_ack(service: MessagingService,
queue_to_consume: Queue, publisher,
message):
receiver: PersistentMessageReceiver = service.create_persistent_message_receiver_builder() \
.with_message_auto_acknowledgement().build(queue_to_consume)
receiver.start()
print(
f'PERSISTENT receiver started... Listening to Queue [{queue_to_consume.get_name()}]'
)
receiver.add_subscription(TopicSubscription.of(topic_name))
HowToPublishPersistentMessage.publish_string_message_non_blocking(
publisher, topic, message)
message: InboundMessage = receiver.receive_message()
print(f"the message payload is {message.get_payload_as_string()}")
def run():
try:
message = constants.MESSAGE_TO_SEND
messaging_service = SamplerMaster.connect_messaging_service()
publisher = HowToPublishPersistentMessage.create_persistent_message_publisher(
messaging_service)
HowToConsumeMessageExclusiveVsSharedMode\
.PersistentMessageReceiverQueueAccessTypes\
.receive_from_durable_exclusive_queue(messaging_service, topic, publisher, message)
HowToConsumeMessageExclusiveVsSharedMode \
.PersistentMessageReceiverQueueAccessTypes \
.receive_from_non_durable_exclusive_queue(messaging_service, topic, publisher, message)
HowToConsumeMessageExclusiveVsSharedMode \
.PersistentMessageReceiverQueueAccessTypes \
.receive_from_durable_non_exclusive_queue(messaging_service, topic, publisher, message)
HowToConsumeMessageExclusiveVsSharedMode \
.PersistentMessageReceiverQueueAccessTypes \
.receive_with_state_change_listener(messaging_service, topic, publisher, message)
HowToConsumeMessageExclusiveVsSharedMode \
.consume_full_message_and_do_ack_using_receive_message(messaging_service, topic, publisher, message)
HowToConsumeMessageExclusiveVsSharedMode \
.consume_using_message_selector(messaging_service, topic, publisher, message)
finally:
publisher.terminate(0)
def consume_full_message_using_callback_and_do_ack(
service: MessagingService, queue_to_consume: Queue, publisher,
message):
try:
receiver: PersistentMessageReceiver = service.create_persistent_message_receiver_builder() \
.with_message_auto_acknowledgement().build(queue_to_consume)
receiver.start()
print(
f'PERSISTENT receiver started... Listening to Queue [{queue_to_consume.get_name()}]'
)
receiver.add_subscription(TopicSubscription.of(topic_name))
message_handler = BasicTestMessageHandler()
receiver.receive_async(message_handler)
HowToPublishPersistentMessage.publish_string_message_non_blocking(
publisher, topic, message)
finally:
receiver.terminate(0)
HowToConsumeMessageExclusiveVsSharedMode.delete_queue(
queue_to_consume.get_name())
def receive_with_state_change_listener(messaging_service, topic,
publisher, message):
"""method to build and receive messages using receiver state change listener"""
try:
queue_name = constants.QUEUE_NAME_FORMAT.substitute(
iteration=topic_name)
HowToConsumeMessageExclusiveVsSharedMode.create_queue_and_add_topic(
queue_name)
durable_non_exclusive_queue = Queue.durable_non_exclusive_queue(
queue_name)
passivation_activation_listener = ReceiverStateChangeListenerImpl(
)
receiver = HowToConsumeMessageExclusiveVsSharedMode \
.create_persistent_message_receiver_with_activation_passivation_support \
(messaging_service, durable_non_exclusive_queue, passivation_activation_listener)
message_receiver = BasicTestMessageHandler()
receiver.receive_async(message_receiver)
semp.shutdown_queue(
queue_name=queue_name,
msg_vpn_name=broker_props[service_properties.VPN_NAME])
semp.re_enable_queue(
queue_name=queue_name,
msg_vpn_name=broker_props[service_properties.VPN_NAME])
HowToPublishPersistentMessage.publish_string_message_non_blocking(
publisher, topic, message)
time.sleep(1)
print(
f'Message received count: {message_receiver.total_message_received_count}'
)
finally:
receiver.terminate(0)
HowToConsumeMessageExclusiveVsSharedMode.delete_queue(
queue_name)
def run():
try:
message = constants.MESSAGE_TO_SEND
messaging_service = SamplerMaster.connect_messaging_service()
publisher = HowToPublishPersistentMessage.create_persistent_message_publisher(
messaging_service)
queue_name = constants.QUEUE_NAME_FORMAT.substitute(
iteration=topic_name)
HowToConsumeMessageExclusiveVsSharedMode.create_queue_and_add_topic(
queue_name)
durable_exclusive_queue = Queue.durable_exclusive_queue(queue_name)
HowToConsumePersistentMessageWithAutoAcknowledgement \
.consume_full_message_and_do_ack(service=messaging_service, queue_to_consume=durable_exclusive_queue,
publisher=publisher, message=message)
HowToConsumePersistentMessageWithAutoAcknowledgement \
.consume_full_message_using_callback_and_do_ack(service=messaging_service,
queue_to_consume=durable_exclusive_queue,
publisher=publisher, message=message)
finally:
messaging_service.disconnect()