def blocking_consume_direct_messages_in_loop_with_time_out(
service: MessagingService, consumer_subscription: str,
receive_timeout):
try:
topics = [TopicSubscription.of(consumer_subscription)]
receiver: DirectMessageReceiver = service.create_direct_message_receiver_builder()\
.with_subscriptions(topics).build()
receiver.start()
count = 0
for count in range(100):
try:
with ThreadPoolExecutor(max_workers=1) as e:
e.submit(
HowToDirectPublishMessage.direct_message_publish,
messaging_service=service,
destination=Topic.of(consumer_subscription),
message=constants.MESSAGE_TO_SEND)
message_payload: 'InboundMessage' = receiver.receive_message(
receive_timeout)
print(
f"message_payload in string: {message_payload.get_payload_as_string()}, msg_count: {count}"
)
except PubSubPlusClientError as exception:
raise exception
finally:
receiver.terminate()
def consume_direct_message_published_from_rest_client(
service: MessagingService, consumer_subscription: str):
"""To consume direct message payload with content type and content encoding using receive_message()"""
try:
topics = [TopicSubscription.of(consumer_subscription)]
receiver: DirectMessageReceiver = service.create_direct_message_receiver_builder()\
.with_subscriptions(topics).build()
receiver.start()
with ThreadPoolExecutor(max_workers=1) as e:
e.submit(HowToDirectPublishMessage.
direct_message_publish_outbound_with_all_props,
messaging_service=service,
destination=Topic.of(consumer_subscription),
message=constants.MESSAGE_TO_SEND)
message_payload: 'InboundMessage' = receiver.receive_message()
rest_specific_fields = message_payload.get_rest_interoperability_support(
)
content_type = rest_specific_fields.get_http_content_type()
content_encoding = rest_specific_fields.get_http_content_encoding()
print(
f"received message content type is :{content_type} \n content encoding is : {content_encoding}"
)
finally:
receiver.terminate()
def run():
"""
:return:
"""
service = None
try:
service = MessagingService.builder().from_properties(
boot.broker_properties()).build()
service.connect()
print(f"Message service: {service.is_connected}")
if service.is_connected:
destination_name = Topic.of(constants.TOPIC_ENDPOINT_DEFAULT)
message_count = 10
print(
"Execute Direct Publish - String without using back pressure"
)
HowToDirectMessagingHealthCheckSampler() \
.direct_message_publish_without_backpressure(service, destination_name,
constants.MESSAGE_TO_SEND,
message_count)
buffer_capacity = 100
print("Execute Direct Publish - String using back pressure")
HowToDirectMessagingHealthCheckSampler() \
.direct_message_publish_on_backpressure_reject(service, destination_name,
constants.MESSAGE_TO_SEND,
buffer_capacity, message_count)
else:
print(
f'Failed to connect service with properties: {boot.broker_properties()}'
)
finally:
if service:
service.disconnect()
def run():
"""
:return:
"""
try:
service = MessagingService.builder().from_properties(
boot.broker_properties()).build()
result = service.connect_async().result()
print(f"Message service status: {result}")
if result == 0:
destination_name = Topic.of(constants.TOPIC_ENDPOINT_DEFAULT)
message_count = 10
print(
"Execute Direct Publish - String without using back pressure"
)
HowToDirectMessagingHealthCheckSampler() \
.direct_message_publish_without_backpressure(service, destination_name,
constants.MESSAGE_TO_SEND,
message_count)
buffer_capacity = 100
print("Execute Direct Publish - String using back pressure")
HowToDirectMessagingHealthCheckSampler() \
.direct_message_publish_on_backpressure_reject(service, destination_name,
constants.MESSAGE_TO_SEND,
buffer_capacity, message_count)
finally:
service.disconnect_async()
def run():
"""
:return:
"""
service = None
try:
service = MessagingService.builder().from_properties(
boot.broker_properties()).build()
service.connect()
print(f"Message service connected: {service.is_connected}")
if service.is_connected:
destination_name = Topic.of(constants.TOPIC_ENDPOINT_DEFAULT)
message_count = 10
buffer_capacity = 100
print("Execute Direct Publish - String using back pressure")
HowToDirectPublishWithBackPressureSampler() \
.direct_message_publish_on_backpressure_reject(service, destination_name, constants.MESSAGE_TO_SEND,
buffer_capacity, message_count)
print(
"Execute Direct Publish - String Outbound Message with all props using back pressure"
)
HowToDirectPublishWithBackPressureSampler(). \
direct_message_publish_outbound_with_all_props_on_backpressure_on_reject(service, destination_name,
constants.MESSAGE_TO_SEND
+ "_outbound based",
buffer_capacity,
message_count)
print(
"Execute Direct Publish - String Outbound Message with all props using back pressure elastic"
)
HowToDirectPublishWithBackPressureSampler() \
.direct_message_publish_outbound_with_all_props_on_backpressure_elastic(service, destination_name,
constants.MESSAGE_TO_SEND +
"_outbound based",
message_count)
print(
"Execute Direct Publish - String Outbound Message with all props using back pressure wait"
)
HowToDirectPublishWithBackPressureSampler() \
.direct_message_publish_outbound_with_all_props_on_backpressure_wait(service, destination_name,
constants.MESSAGE_TO_SEND
+ str("_outbound based"),
buffer_capacity,
message_count)
else:
print(
"failed to connect service with properties: {boot.broker_properties}"
)
finally:
if service:
service.disconnect()
def publish_message_with_unique_service():
try:
service = MessagingService.builder().from_properties(
boot.broker_properties()).build()
service.connect_async()
destination_name = Topic.of(constants.TOPIC_ENDPOINT_DEFAULT)
direct_publish_service = service.create_direct_message_publisher_builder(
).build()
direct_publish_service.start_async()
direct_publish_service.publish(destination=destination_name,
message=constants.MESSAGE_TO_SEND)
finally:
service.disconnect()
direct_publish_service.terminate(0)
def run():
"""
this method creates a messaging service connection and publishes the message
"""
service = MessagingService.builder().from_properties(
boot.broker_properties()).build()
service.connect_async()
destination_name = Topic.of(constants.TOPIC_ENDPOINT_DEFAULT)
print("Execute Direct Publish - Generics Outbound Message")
HowToDirectMessagePublishBusinessObject() \
.direct_message_publish_outbound_business_obj(service, destination_name,
message_obj=MyData('some value'),
converter=PopoConverter())
def consume_direct_message_byte_payload(service: MessagingService,
consumer_subscription: str):
"""To consume direct message payload in bytes using receive_message()"""
try:
topics = [TopicSubscription.of(consumer_subscription)]
receiver: DirectMessageReceiver = service.create_direct_message_receiver_builder()\
.with_subscriptions(topics).build()
receiver.start()
with ThreadPoolExecutor(max_workers=1) as e:
e.submit(HowToDirectPublishMessage.direct_message_publish,
messaging_service=service,
destination=Topic.of(consumer_subscription),
message=constants.MESSAGE_TO_SEND)
message_payload = receiver.receive_message().get_payload_as_bytes()
print(f"received message payload in bytes is : {message_payload}")
finally:
receiver.terminate()
def run():
try:
messaging_service = MessagingService.builder().from_properties(
boot.broker_properties()).build()
messaging_service.connect_async()
destination_name = Topic.of(constants.TOPIC_ENDPOINT_DEFAULT)
buffer_capacity = 20
message_count = 50
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)
finally:
messaging_service.disconnect_async()
def run():
try:
message = constants.MESSAGE_TO_SEND
messaging_service = MessagingService.builder().from_properties(boot.broker_properties()).build()
messaging_service.connect()
print(f'Message service is connected? {messaging_service.is_connected}')
topic_name = constants.TOPIC_ENDPOINT_DEFAULT
topic = Topic.of(topic_name)
outbound_msg = messaging_service.message_builder() \
.with_application_message_id(constants.APPLICATION_MESSAGE_ID)
publisher = HowToPublishPersistentMessage.create_persistent_message_publisher(messaging_service)
HowToPublishPersistentMessage.publish_byte_message_non_blocking(publisher, topic,
bytearray(message,
_sol_constants.ENCODING_TYPE))
HowToPublishPersistentMessage.publish_string_message_non_blocking(publisher, topic, message)
HowToPublishPersistentMessage.publish_typed_message_non_blocking(message_builder=outbound_msg,
message_publisher=publisher,
destination=topic,
message=message)
HowToPublishPersistentMessage \
.publish_typed_message_with_extended_message_props_non_blocking(message_builder=outbound_msg,
message_publisher=publisher,
destination=topic,
message=message)
HowToPublishPersistentMessage \
.correlate_message_on_broker_ack_with_user_context_non_blocking(message_builder=outbound_msg,
message_publisher=publisher,
destination=topic,
message=message)
HowToPublishPersistentMessage \
.publish_byte_message_blocking_waiting_for_publisher_confirmation(messaging_service=messaging_service,
message_publisher=publisher,
destination=topic,
message=message,
time_out=2000)
finally:
publisher.terminate()
messaging_service.disconnect()
def add_listener_when_reconnection_happens(retries: int, retry_interval: int) -> 'MessagingService':
"""method adds a reconnection listener when an reconnection happens using the reconnection strategy
Args:
retries (int): the number of retries count
retry_interval (int): the retry interval value
Returns:
the listener events
"""
events = list()
def on_reconnection(event_p):
events.append(event_p)
print("current event", events)
try:
destination_name = Topic.of(constants.TOPIC_ENDPOINT_DEFAULT)
message = constants.MESSAGE_TO_SEND
number_of_message_to_send = 10
messaging_service = MessagingService.builder().from_properties(boot.broker_properties()) \
.with_reconnection_retry_strategy(RetryStrategy.parametrized_retry(retries, retry_interval)) \
.add_reconnection_listener(on_reconnection).build()
messaging_service1_status_code = messaging_service.connect_async()
print("messaging service status code: ", messaging_service1_status_code)
for _ in range(number_of_message_to_send):
publish_service = messaging_service.create_direct_message_publisher_builder().build()
publish_service.publish(destination=destination_name, message=message)
session_force_failure_status = messaging_service.disconnect_force()
print("session force failure status: ", session_force_failure_status)
for _ in range(number_of_message_to_send):
publish_service = messaging_service.create_direct_message_publisher_builder().build()
publish_service.publish(destination=destination_name, message=message)
messaging_service.disconnect()
finally:
timeout = time.time() + 60 * 1
while True:
if 13 in events or time.time() > timeout:
break
return events # MessagingService got list
def publish_mesg(transaction_str):
# Create a direct message publisher and start it
direct_publisher = messaging_service.create_direct_message_publisher_builder().build()
direct_publisher.set_publish_failure_listener(PublisherErrorHandling())
direct_publisher.set_publisher_readiness_listener
# Blocking Start thread
direct_publisher.start()
outbound_msg = messaging_service.message_builder() \
.with_application_message_id("sample_id") \
.with_property("application", "samples") \
.with_property("language", "Python") \
.build(transaction_str)
msgSeqNum = 1
print("transaction details: ", str(transaction_str))
direct_publisher.publish(destination=Topic.of(TOPIC_TST + f"/python/{msgSeqNum}"), message=outbound_msg)
direct_publisher.terminate()
def run():
messaging_service = None
try:
reply_timeout = 10000
topic_name = f'request_reply/pub_sub/sampler'
topic = Topic.of(topic_name)
topic_subscription = TopicSubscription.of(topic_name)
messaging_service = MessagingService.builder().from_properties(SamplerBoot().broker_properties()).build()
messaging_service.connect()
HowToUseRequestReplyPattern.async_request_and_response(service=messaging_service,
request_destination=topic,
for_requests=topic_subscription,
reply_timeout=reply_timeout)
HowToUseRequestReplyPattern.blocking_request_and_response(service=messaging_service,
request_destination=topic,
for_requests=topic_subscription,
reply_timeout=reply_timeout)
finally:
if messaging_service:
messaging_service.disconnect()
def publish_request_and_process_response_message_async(service: MessagingService, request_destination: Topic,
reply_timeout: int):
"""Mimics microservice that performs a async request
Args:
service: connected messaging service
request_destination: where to send a request (it is same for requests and responses)
reply_timeout: the reply timeout
"""
topic = Topic.of(request_destination)
requester: RequestReplyMessagePublisher = service.request_reply() \
.create_request_reply_message_publisher_builder().build().start()
try:
ping_message = service.message_builder().build(payload='Ping',
additional_message_properties={SEQUENCE_NUMBER: 123})
publish_request_async = requester.publish(request_message=ping_message,
request_destination=topic,
reply_timeout=reply_timeout)
# we can get the reply from the future
print(publish_request_async.result())
finally:
requester.terminate()
def consume_direct_detailed_message(service: MessagingService,
consumer_subscription: str):
try:
topics = [TopicSubscription.of(consumer_subscription)]
receiver: DirectMessageReceiver = service.create_direct_message_receiver_builder()\
.with_subscriptions(topics).build()
receiver.start()
with ThreadPoolExecutor(max_workers=1) as e:
e.submit(HowToDirectPublishMessage.
direct_message_publish_outbound_with_all_props,
messaging_service=service,
destination=Topic.of(consumer_subscription),
message=constants.MESSAGE_TO_SEND)
message_payload: 'InboundMessage' = receiver.receive_message()
expiration = message_payload.get_expiration()
print(
f"received message payload is :{message_payload.get_payload_as_string()} "
f"\n expiration is : {expiration}")
finally:
receiver.terminate()
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()
from solace.messaging.receiver.persistent_message_receiver import PersistentMessageReceiver
from solace.messaging.resources.queue import Queue
from solace.messaging.resources.topic import Topic
from solace.messaging.resources.topic_subscription import TopicSubscription
from howtos.pubsub.how_to_consume_persistent_message import HowToConsumeMessageExclusiveVsSharedMode
from howtos.pubsub.how_to_publish_persistent_message import HowToPublishPersistentMessage
from howtos.sampler_boot import SolaceConstants, SamplerBoot, BasicTestMessageHandler
from howtos.sampler_master import SamplerMaster
X = TypeVar('X')
constants = SolaceConstants
boot = SamplerBoot()
lock = threading.Lock()
topic_name = constants.TOPIC_ENDPOINT_DEFAULT
topic = Topic.of(topic_name)
class HowToConsumePersistentMessageWithAutoAcknowledgement:
"""class contains methods to consume message with auto acknowledgement"""
@staticmethod
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)
if direct_receiver.is_running():
print("Connected and Subscribed! Ready to publish\n")
try:
while not SHUTDOWN:
msgSeqNum += 1
# Check https://docs.solace.com/API-Developer-Online-Ref-Documentation/python/source/rst/solace.messaging.config.solace_properties.html for additional message properties
# Note: additional properties override what is set by the message_builder
additional_properties = {
APPLICATION_MESSAGE_ID: f'sample_id {msgSeqNum}'
}
# Creating a dynamic outbound message
outbound_message = message_builder.build(
f'{message_body} --> {msgSeqNum}',
additional_message_properties=additional_properties)
# Direct publish the message
direct_publisher.publish(destination=Topic.of(
TOPIC_PREFIX + f"/python/hello/{unique_name}/{msgSeqNum}"),
message=outbound_message)
# sleep are not necessary when dealing with the default back pressure elastic
time.sleep(5)
except KeyboardInterrupt:
print('\nDisconnecting Messaging Service')
except PubSubPlusClientError as exception:
print(f'Received a PubSubPlusClientException: {exception}')
finally:
print('Terminating Publisher and Receiver')
direct_publisher.terminate()
direct_receiver.terminate()
print('Disconnecting Messaging Service')
messaging_service.disconnect()
.build(message_body)
try:
print(f"Subscribed to: {topics}")
# Build a Receiver
direct_receiver = messaging_service.create_direct_message_receiver_builder(
).with_subscriptions(topics_sub).build()
direct_receiver.start()
# Callback for received messages
direct_receiver.receive_async(MessageHandlerImpl())
if direct_receiver.is_running():
print("Connected and Subscribed! Ready to publish\n")
try:
while not SHUTDOWN:
# Direct publish the message
direct_publisher.publish(
destination=Topic.of(TOPIC_PREFIX +
f"/python/{unique_name}/{msgSeqNum}"),
message=outbound_msg)
msgSeqNum += 1
# Modifying the outbond message instead of creating a new one
outbound_msg.solace_message.message_set_binary_attachment_string(
f'{message_body} --> {msgSeqNum}')
outbound_msg.solace_message.set_message_application_message_id(
f'sample_id {msgSeqNum}')
time.sleep(0.1)
except KeyboardInterrupt:
print('\nDisconnecting Messaging Service')
except PubSubPlusClientError as exception:
print(f'Received a PubSubPlusClientException: {exception}')
finally:
print('Terminating Publisher and Receiver')
direct_publisher.terminate()
def run():
messaging_service = MessagingService.builder().from_properties(
boot.broker_properties()).build()
try:
messaging_service.connect()
destination_name = Topic.of(constants.TOPIC_ENDPOINT_DEFAULT)
print("Execute Direct Publish - String")
HowToDirectPublishMessage() \
.direct_message_publish(messaging_service, destination_name, constants.MESSAGE_TO_SEND)
print("Execute Direct Publish - Byte Array")
HowToDirectPublishMessage() \
.direct_message_publish(messaging_service, destination_name,
bytearray(constants.MESSAGE_TO_SEND, _sol_constants.ENCODING_TYPE))
print("Execute Direct Publish - String Outbound Message")
HowToDirectPublishMessage() \
.direct_message_publish_outbound(messaging_service, destination_name,
constants.MESSAGE_TO_SEND + str("_outbound based"))
print("Execute Direct Publish - Byte Array Outbound Message")
HowToDirectPublishMessage() \
.direct_message_publish_outbound(messaging_service, destination_name,
bytearray(constants.MESSAGE_TO_SEND + str("_outbound based"),
_sol_constants.ENCODING_TYPE))
print(
"Execute Direct Publish - Byte Array Outbound Message with props"
)
HowToDirectPublishMessage() \
.direct_message_publish_outbound_properties(messaging_service, destination_name,
bytearray(constants.MESSAGE_TO_SEND +
str("_outbound based with props"),
_sol_constants.ENCODING_TYPE))
print(
"Execute Direct Publish - String Outbound Message with all props"
)
HowToDirectPublishMessage(). \
direct_message_publish_outbound_with_all_props(messaging_service, destination_name,
constants.MESSAGE_TO_SEND + str("_outbound based"))
print("Execute Direct Publish - Generics Outbound Message")
HowToDirectPublishMessage() \
.direct_message_publish_outbound_business_obj(messaging_service, destination_name,
message_obj=MyData('some value'),
converter=PopoConverter())
print("Execute Direct Publish - Concurrent testing")
tasks = []
with ThreadPoolExecutor() as executor:
for e in range(
10): # make sure you have try-me1 & try-me2 already
destination_name = Topic.of(constants.TOPIC_ENDPOINT_2)
if e % 2 == 0:
destination_name = Topic.of(constants.TOPIC_ENDPOINT_1)
future = executor.submit(
HowToDirectPublishMessage().direct_message_publish,
messaging_service, destination_name,
constants.MESSAGE_TO_SEND)
tasks.append(future)
finally:
api_metrics = HowToAccessApiMetrics()
api_metrics.access_individual_api_metrics(
messaging_service, Metric.TOTAL_MESSAGES_SENT)
api_metrics.to_string_api_metrics(messaging_service)
messaging_service.disconnect()
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)
# Create a persistent message publisher and start it
publisher: PersistentMessagePublisher = messaging_service.create_persistent_message_publisher_builder(
).build()
publisher.start_async()
# set a message delivery listener to the publisher
receipt_listener = MessageReceiptListener()
publisher.set_message_publish_receipt_listener(receipt_listener)
# Prepare the destination topic
topic = Topic.of(TOPIC_PREFIX + f'/persistent/pub')
# Prepare outbound message payload and body
message_body = "this is the body of the msg"
outbound_msg_builder = messaging_service.message_builder() \
.with_application_message_id("sample_id") \
.with_property("application", "samples") \
.with_property("language", "Python")
count = 0
try:
while True:
outbound_msg = outbound_msg_builder \
.with_application_message_id(f'NEW {count}')\
.build(f'{message_body} + {count}')
publisher.publish(outbound_msg, topic)
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)
# Create a persistent message publisher and start it
publisher: PersistentMessagePublisher = messaging_service.create_persistent_message_publisher_builder(
).build()
publisher.start_async()
# set a message delivery listener to the publisher
receipt_listener = MessageReceiptListener()
publisher.set_message_publish_receipt_listener(receipt_listener)
# Prepare the destination topic
topic = Topic.of(TOPIC_PREFIX)
# Prepare outbound message payload and body
message_body = "this is the body of the msg"
outbound_msg_builder = messaging_service.message_builder() \
.with_application_message_id("sample_id") \
.with_property("application", "samples") \
.with_property("language", "Python")
count = 0
try:
while True:
outbound_msg = outbound_msg_builder \
.with_application_message_id(f'NEW {count}')\
.build(f'{message_body} + {count}')
publisher.publish(outbound_msg, topic)
def consume_just_SDTMapStream_payload(messaging_service,
consumer_subscription):
""" to consume message"""
print("consume here testing")
try:
# Create a direct message publisher and start it
direct_publisher = messaging_service.create_direct_message_publisher_builder(
).build()
# Blocking Start thread
direct_publisher.start()
print("messaging_service in consumer : ", messaging_service)
topics = [TopicSubscription.of(consumer_subscription)]
receiver: DirectMessageReceiver = messaging_service.create_direct_message_receiver_builder() \
.with_subscriptions(topics).build()
print("Receiver started...")
receiver.start()
# Callback for received messages
receiver.receive_async(MessageHandlerImpl())
MESSAGE_TO_SEND = [
[1, 'c', None,
bytearray(b'1'), {
'a': 2
}, True, 5.5],
({
"key1": 1,
"key2": 2
}, {
"key1": 'value1',
"key2": 2
}, {
"key1": tuple(["John", "Doe", "Alice"])
}), {
"key1": 'value1',
"key2": True,
"key3": {
"key31": None,
"key32": {
"5": 6,
"7": {
"8": 9
}
}
},
"key4": [1.1, None, 3, {
"key42": [1, 2, 3]
}],
"key5": bytearray([0x13, 0x11, 0x10, 0x09, 0x08, 0x01]),
"key6": '',
"key7": (1, 2, 3)
}, {
"1": 2,
"3": {
"5": 6,
"7": {
"8": 9
},
"11": {
"a": "b",
"c": [1, 2, 3]
}
}
}, 'hello everyone'
]
tasks = []
with ThreadPoolExecutor() as executor:
for message in MESSAGE_TO_SEND:
future = executor.submit(
HowToWorkWithSolaceSDTTypesAndMessages.publish_SDTMap,
messaging_service=messaging_service,
destination=Topic.of(consumer_subscription),
message=message)
tasks.append(future)
# can wait of tasks or wait for for first task using concurrent.futures methods
# on context exit all pending tasks in the executor must complete
finally:
print("Terminating receiver")
receiver.terminate()
direct_publisher.start()
print(f'Direct Publisher ready? {direct_publisher.is_ready()}')
# Prepare outbound message payload and body
message_body = "this is the body of the msg"
outbound_msg_builder = messaging_service.message_builder() \
.with_application_message_id("sample_id") \
.with_property("application", "samples") \
.with_property("language", "Python") \
count = 1
print("\nSend a KeyboardInterrupt to stop publishing\n")
try:
while True:
while count <= MSG_COUNT:
topic = Topic.of(TOPIC_PREFIX + f'/python/{count}')
# Direct publish the message with dynamic headers and payload
outbound_msg = outbound_msg_builder \
.with_application_message_id(f'NEW {count}')\
.build(f'{message_body} + {count}')
direct_publisher.publish(destination=topic, message=outbound_msg)
print(f'Published message on {topic}')
count += 1
time.sleep(0.1)
print("\n")
count = 1
time.sleep(1)
except KeyboardInterrupt:
print('\nTerminating Publisher')
"RideUpdated send",
kind=SpanKind.PRODUCER,
attributes={
"messaging.system": "solace",
"messaging.destination": outboundTopic,
"messaging.destination-kind": "topic",
"messaging.protocol": "jcsmp",
"messaging.protocol_version": "1.0",
"messaging.url": os.environ['SOLACE_HOST']}
)
messaging_service = MessagingService.builder().from_properties(broker_props).build()
messaging_service.connect_async()
trace_id = parentSpan.get_context().trace_id
span_id = parentSpan.get_context().span_id
print("parentSpan trace_id on sender side:" + str(trace_id))
print("parentSpan span_id on sender side:" + str(span_id))
destination_name = Topic.of(outboundTopic)
outbound_msg = messaging_service.message_builder() \
.with_property("trace_id", str(trace_id)) \
.with_property("span_id", str(span_id)) \
.build("Hello World! This is a message published from Python!")
direct_message_publish(messaging_service, destination_name, outbound_msg)
parentSpan.end()
direct_publisher.start()
print(f'Direct Publisher ready? {direct_publisher.is_ready()}')
# Prepare outbound message payload and body
message_body = "this is the body of the msg"
outbound_msg_builder = messaging_service.message_builder() \
.with_application_message_id("sample_id") \
.with_property("application", "samples") \
.with_property("language", "Python") \
count = 1
print("\nSend a KeyboardInterrupt to stop publishing\n")
try:
while True:
while count <= MSG_COUNT:
topic = Topic.of(TOPIC_PREFIX + f'/direct/pub/{count}')
# Direct publish the message with dynamic headers and payload
outbound_msg = outbound_msg_builder \
.with_application_message_id(f'NEW {count}')\
.build(f'{message_body} + {count}')
direct_publisher.publish(destination=topic, message=outbound_msg)
print(f'Published message on {topic}')
count += 1
time.sleep(0.1)
print("\n")
count = 1
time.sleep(1)
except KeyboardInterrupt:
print('\nTerminating Publisher')
