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_using_receive_message(
messaging_service, topic, publisher, message):
"""method to consume persistent message and do ack at later time using receive_message"""
queue_name = constants.QUEUE_NAME_FORMAT.substitute(
iteration=topic_name)
try:
HowToConsumeMessageExclusiveVsSharedMode.create_queue_and_add_topic(
queue_name)
queue = Queue.durable_exclusive_queue(queue_name)
receiver = messaging_service.create_persistent_message_receiver_builder() \
.build(queue)
receiver.start()
receiver.add_subscription(TopicSubscription.of(topic_name))
with ThreadPoolExecutor(max_workers=1) as e:
time.sleep(2)
e.submit(
HowToPublishPersistentMessage.
publish_string_message_non_blocking, publisher, topic,
message)
message_received: 'InboundMessage' = receiver.receive_message(
timeout=DEFAULT_TIMEOUT)
receiver.ack(message_received)
print(
f"received message: {message_received.get_payload_as_string()}"
)
finally:
receiver.terminate(0)
HowToConsumeMessageExclusiveVsSharedMode.delete_queue(
queue_name=queue_name)
def run():
messaging_service = None
try:
# we're assuming replay_log is already created and pub/sub is already done in the queue/topic
queue_name = 'Q/test/replay/pub_sub'
messaging_service = SamplerMaster.connect_messaging_service()
durable_exclusive_queue = Queue.durable_exclusive_queue(queue_name)
HowToTriggerReplayPersistentMessage \
.all_messages_replay(service=messaging_service, queue_to_consume=durable_exclusive_queue)
HowToTriggerReplayPersistentMessage \
.time_based_replay(service=messaging_service, queue_to_consume=durable_exclusive_queue)
finally:
if messaging_service:
messaging_service.disconnect()
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()
HowToConsumeMessageExclusiveVsSharedMode.delete_queue(queue_to_consume.get_name())
def consume_using_message_selector(messaging_service, topic, publisher,
message):
"""method to consume persistent message and do ack at later time using receive_message"""
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)
msg_selector_expression = "JMSCorrelationID = '1' and JMSPriority = 1"
receiver = messaging_service.create_persistent_message_receiver_builder() \
.with_message_selector(msg_selector_expression) \
.build(durable_non_exclusive_queue)
receiver.start()
receiver.add_subscription(TopicSubscription.of(topic_name))
outbound_msg = messaging_service.message_builder() \
.with_application_message_id(constants.APPLICATION_MESSAGE_ID) \
.with_priority(constants.MESSAGE_PRIORITY) \
.with_expiration(constants.MESSAGE_EXPIRATION)
additional_message_properties = {CORRELATION_ID: '1', PRIORITY: 1}
with ThreadPoolExecutor(max_workers=1) as e:
time.sleep(3)
e.submit(
HowToPublishPersistentMessage.
publish_typed_message_with_extended_message_props_non_blocking,
outbound_msg, publisher, topic, message,
additional_message_properties)
message_received: 'InboundMessage' = receiver.receive_message(
timeout=DEFAULT_TIMEOUT)
receiver.ack(message_received)
print(
f"received message: {message_received.get_payload_as_string()}"
)
finally:
receiver.terminate(0)
HowToConsumeMessageExclusiveVsSharedMode.delete_queue(
queue_name=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()
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:
messaging_service = MessagingService.builder().from_properties(boot.broker_properties()).build()
messaging_service.connect()
destination_name = Topic.of(constants.TOPIC_ENDPOINT_DEFAULT)
buffer_capacity = 20
message_count = 50
queue_name = 'Q/test/pub_sub'
durable_exclusive_queue = Queue.durable_exclusive_queue(queue_name)
HowToHandleServiceInterruptionAndFailures.notify_on_direct_publisher_failures(messaging_service,
destination_name,
constants.MESSAGE_TO_SEND,
buffer_capacity,
message_count)
HowToHandleServiceInterruptionAndFailures. \
notify_about_service_access_unrecoverable_interruption(messaging_service,
destination_name, constants.MESSAGE_TO_SEND)
HowToHandleServiceInterruptionAndFailures. \
notify_about_persistent_receiver_termination(messaging_service, queue=durable_exclusive_queue)
finally:
messaging_service.disconnect()
.build()
# Blocking connect thread
messaging_service.connect()
print(f'Messaging Service connected? {messaging_service.is_connected}')
# Event Handling for the messaging service
service_handler = ServiceEventHandler()
messaging_service.add_reconnection_listener(service_handler)
messaging_service.add_reconnection_attempt_listener(service_handler)
messaging_service.add_service_interruption_listener(service_handler)
# Queue name.
# NOTE: This assumes that a persistent queue already exists on the broker with the right topic subscription
queue_name = "sample-queue"
durable_exclusive_queue = Queue.durable_exclusive_queue(queue_name)
try:
# Build a receiver and bind it to the durable exclusive queue
persistent_receiver: PersistentMessageReceiver = messaging_service.create_persistent_message_receiver_builder()\
.with_message_auto_acknowledgement()\
.build(durable_exclusive_queue)
persistent_receiver.start()
# Callback for received messages
persistent_receiver.receive_async(MessageHandlerImpl())
print(f'PERSISTENT receiver started... Bound to Queue [{durable_exclusive_queue.get_name()}]')
try:
while True:
time.sleep(1)
except KeyboardInterrupt: