def direct_message_consume_adding_subscriptions( messaging_service: MessagingService, consumer_subscription: str, listener_topics: list): """ to publish str or byte array type message Args: messaging_service: connected messaging service consumer_subscription: Each topic subscribed listener_topics: list of topics subscribed to """ try: global MAX_SLEEP topics = [TopicSubscription.of(consumer_subscription)] direct_receive_service = messaging_service.create_direct_message_receiver_builder( ) direct_receive_service = direct_receive_service.with_subscriptions( topics).build() direct_receive_service.start() direct_receive_service.receive_async(MessageHandlerImpl1()) for topic in listener_topics: direct_receive_service.add_subscription( TopicSubscription.of(topic)) print(f"Subscribed to: {consumer_subscription}") time.sleep(MAX_SLEEP) finally: direct_receive_service.terminate()
def direct_message_consume_adding_subscriptions( messaging_service: MessagingService, consumer_subscription: str, listener_topics: list): """ to publish str or byte array type message""" try: topics = [TopicSubscription.of(consumer_subscription)] direct_receive_service = messaging_service.create_direct_message_receiver_builder( ) direct_receive_service = direct_receive_service.with_subscriptions( topics).build() direct_receive_service.start() direct_receive_service.receive_async(MessageHandlerImpl1()) for topic in listener_topics: direct_receive_service.add_subscription( TopicSubscription.of(topic)) print(f"Subscribed to: {consumer_subscription}") while True: global MAX_SLEEP if MAX_SLEEP <= 0: break else: MAX_SLEEP -= 1 time.sleep(1) finally: direct_receive_service.terminate(0)
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 direct_message_consume(messaging_service: MessagingService, consumer_subscription: str): """ to publish str or byte array type message""" try: global MAX_SLEEP topics = [TopicSubscription.of(consumer_subscription)] direct_receive_service = messaging_service.create_direct_message_receiver_builder( ) direct_receive_service = direct_receive_service.with_subscriptions( topics).build() direct_receive_service.start() direct_receive_service.receive_async(MessageHandlerImpl()) remaining_time = MAX_SLEEP print(f"Subscribed to: {consumer_subscription}") time.sleep(MAX_SLEEP) finally: api_metrics = HowToAccessApiMetrics() api_metrics.access_individual_api_metrics( messaging_service, Metric.TOTAL_MESSAGES_RECEIVED) api_metrics.to_string_api_metrics(messaging_service) api_metrics.reset_api_metrics(messaging_service) direct_receive_service.terminate()
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 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 create_persistent_message_receiver(messaging_service, queue): """method to create, build and start the persistent message receiver""" receiver = messaging_service.create_persistent_message_receiver_builder( ).build(queue) receiver.start() print( f'PERSISTENT receiver started... Listening to Queue [{queue.get_name()}]' ) receiver.add_subscription(TopicSubscription.of(topic_name)) return receiver
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 create_persistent_message_receiver_with_activation_passivation_support( messaging_service, queue, passivation_activation_listener): """method to create persistent message receiver with the activation and passivation support""" receiver = messaging_service.create_persistent_message_receiver_builder() \ .with_activation_passivation_support(receiver_state_change_listener=passivation_activation_listener) \ .build(queue) receiver.start() print( f'PERSISTENT receiver started with activation passivation support... ' f'Listening to Queue [{queue.get_name()}]') receiver.add_subscription(TopicSubscription.of(topic_name)) return receiver
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_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 direct_message_consume2(messaging_service: MessagingService, consumer_subscription: str): """This method will create an receiver instance to receive str or byte array type message""" try: global MAX_SLEEP topics = [TopicSubscription.of(consumer_subscription)] group_name = ShareName.of('test') direct_receive_service = messaging_service.create_direct_message_receiver_builder( ) direct_receive_service = direct_receive_service.with_subscriptions( topics).build(shared_subscription_group=group_name) direct_receive_service.start() direct_receive_service.receive_async(MessageHandlerImpl2()) print(f"Subscribed to: {consumer_subscription}") time.sleep(MAX_SLEEP) finally: direct_receive_service.terminate() messaging_service.disconnect()
def direct_message_consume_for_business_obj( messaging_service: MessagingService, consumer_subscription: str): """ to publish str or byte array type message""" try: global MAX_SLEEP topics = [TopicSubscription.of(consumer_subscription)] direct_receive_service = messaging_service.create_direct_message_receiver_builder( ) direct_receive_service = direct_receive_service.with_subscriptions( topics).build() direct_receive_service.start() direct_receive_service.receive_async(MessageHandlerImpl()) print(f"Subscribed to: {consumer_subscription}") time.sleep(MAX_SLEEP) finally: direct_receive_service.terminate() messaging_service.disconnect()
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 request_reply_message_consume2(messaging_service: MessagingService, consumer_subscription: str, reply_timeout: int): """This method will create an receiver instance to receive str or byte array type message""" try: global MAX_SLEEP topic_subscription = TopicSubscription.of(consumer_subscription) group_name = ShareName.of('test') receiver = messaging_service.request_reply(). \ create_request_reply_message_receiver_builder().build(request_topic_subscription=topic_subscription, share_name=group_name) receiver.start() msg, replier = receiver.receive_message(timeout=reply_timeout) print(f"incoming message is {msg.get_payload_as_string()}") if replier is not None: outbound_msg = messaging_service.message_builder().build("pong reply") replier.reply(outbound_msg) print(f"Subscribed to: {consumer_subscription}") time.sleep(MAX_SLEEP) finally: receiver.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 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 direct_message_consume(messaging_service: MessagingService, topic_subscription: str): try: trace.set_tracer_provider(TracerProvider()) jaeger_exporter = jaeger.JaegerSpanExporter( service_name="<Solace> REST Messaging call to Security Co", agent_host_name="localhost", agent_port=6831, ) trace.get_tracer_provider().add_span_processor( BatchExportSpanProcessor(jaeger_exporter)) tracer = trace.get_tracer(__name__) topics = [TopicSubscription.of(topic_subscription)] # Create a direct message consumer service with the topic subscription and start it direct_receive_service = messaging_service.create_direct_message_receiver_builder( ) direct_receive_service = direct_receive_service.with_subscriptions( topics).build() direct_receive_service.start() # Register a callback message handler direct_receive_service.receive_async(MessageHandlerImpl()) print(f"Subscribed to: {topic_subscription}") # Infinite loop until Keyboard interrupt is received try: while True: time.sleep(1) except KeyboardInterrupt: print('\nDisconnecting Messaging Service') finally: messaging_service.disconnect() direct_receive_service.terminate()
direct_publisher.set_publish_failure_listener(PublisherErrorHandling()) direct_publisher.set_publisher_readiness_listener # Blocking Start thread direct_publisher.start() # print(f'Direct Publisher ready? {direct_publisher.is_ready()}') unique_name = "" while not unique_name: unique_name = input("Enter your name: ").replace(" ", "") # Define a Topic subscriptions topics = [TOPIC_PREFIX + "/python/>", TOPIC_PREFIX + "/control/>"] topics_sub = [] for t in topics: topics_sub.append(TopicSubscription.of(t)) msgSeqNum = 0 # Prepare outbound message payload and body message_body = f'Hello from Python Hellow World Sample!' outbound_msg = messaging_service.message_builder() \ .with_application_message_id("sample_id") \ .with_property("application", "samples") \ .with_property("language", "Python") \ .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()
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()