rest-solace 0.0.2

REST based library for Solace Message Broker. Publish, Consume, & Manage!!

rest-solace is a rest based python library for Solace Message Broker that allows you to Publish, Consume, & Manage!!

Check it out at PYPI: PYPI page for the project.

Note:

Right now the focus of this library is on the ‘messaging’ mode for solace message VPNs.

In the future I plan to add better support for ‘gateway’ mode as well.

Sending messages to broker:

from rest_solace import MessagingPublisher

publisher_obj = MessagingPublisher(user_name= "admin",
                                   password=" admin",
                                   host= BROKER_IP,
                                   REST_VPNport= VPN_PORT #For 'default' VPN it is 9000
                                   )

#Publish directly to a queue
publish_obj.publishToQueueEndpoint(queue_name= "my_queue",
                                   message= "hello world!!",
                                   delivery_mode= "direct")

#Publish for a given topic string
publish_obj.publishForTopic(topic_string= "test_topic",
                            message= "hello world!!",
                            delivery_mode= "direct")


#Publish directly to a queue and wait for a reply from a consumer
response = publish_obj.publishToQueueEndpoint(queue_name= "my_queue",
                                              message= "hello world!!",
                                              delivery_mode= "persistent",
                                              time_to_live= 10000)
print(response)

#Publish for a given topic string and wait for a reply from a consumer
response = publish_obj.publishForTopic(topic_string= "test_topic",
                                       message= "hello world!!",
                                       delivery_mode= "direct")
print(response)

Receiving messages and sending back a response:

(You can use your own REST server too. The one included with this library is only for simple uses and testing)

from rest_solace import Consumer

consumer_obj = Consumer()

#Receive a single message and get the value returned to you.
incoming_message = consumer_obj.startConsumer(host= CONSUMER_HOST,
                                              port= CONSUMER_PORT,
                                              auto_stop= True #Required for single message mode
                                              )
print(incoming_message)


#Keep receiving messages and handle them through a callback function

def return_uppercase(event:dict, kill_function):
"""Convert request message string to upper case to return as response.
Stops the consumer server if message is "kill".

Args:
    event (dict): contains info about the received request.
    kill_function (function): stops the consumer server if you run it.
Returns:
    str: Returns the incoming message to the publisher in uppercase
"""
byte_string_content= event["content"][1:-1]
regular_string_content= byte_string_content.decode("utf-8")
uppercase_response= str.upper( regular_string_content )

if regular_string_content == "kill":
    kill_function()

return uppercase_response

#You can run this function on a septate thread if you want.
consumer_obj.startConsumer(host= CONSUMER_HOST,
                           port= CONSUMER_PORT,
                           callback_function= return_uppercase,
                           log= True)

Setting up a message VPN for message broking (in messaging mode):

(This is a bit advance but the library includes lots of utility functions to make initial setup easy)

from rest_solace import Manager

manager = Manager(user_name= admin,
                  password= admin,
                  host= BROKER_IP,
                  SEMP_port= SEMP_PORT) #Default rest management port is 8080


#Creating a custom message VPN
#(automatically applies required VPN configuration for rest based communication).
manager.create_message_vpn(msgVpnName= NEW_VPN_NAME,
                           serviceRestIncomingPlainTextListenPort= NEW_VPN_PORT,
                           serviceRestMode= "messaging" #auto configuration will be influenced by this parameter.
                           )


#Setting up your Message VPN for rest based communication
#(For VPN that is in messaging mode)
manager.auto_rest_messaging_setup_utility(msgVpnName= NEW_VPN_NAME, #Existing message VPN

                                          queueName= 'my_queue',  #Creates a new queue

                                          subscriptionTopic=None,  #The topic the queue should subscribe to

                                          restDeliveryPointName='myRDP',  #New RDP to handle incoming messages

                                          restConsumerName='myConsumer',    #A name for your consumer

                                          remoteHost= CONSUMER_HOST,
                                          remotePort= CONSUMER_PORT)