【python】基于python实现solace的消息收发

一、场景

　　测试过程中，需要对solace的消息进行模拟，进而模拟相关业务

 

二、环境

主要的sdk

pip3 install solace-pubsubplus

 

三、代码实现

import asyncio
import json
import logging
from solace.messaging.messaging_service import MessagingService
from solace.messaging.resources.topic import Topic
from solace.messaging.resources.topic_subscription import TopicSubscription
from solace.messaging.config.transport_security_strategy import TLS
from solace.messaging.publisher.direct_message_publisher import PublishFailureListener
from solace.messaging.receiver.message_receiver import MessageHandler
from solace.messaging.receiver.inbound_message import InboundMessage



# 配置日志
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

class PublishCallback(PublishFailureListener):
    def on_failed_publish(self, failed_publish_event):
        logging.error(f"Failed to publish message: {failed_publish_event.get_exception()}")

class SimpleMessageHandler(MessageHandler):
    def on_message(self, message: InboundMessage):
        try:
            payload = message.get_payload_as_string()
            topic = message.get_destination_name()
            logging.info(f"Received message on topic '{topic}': {payload}")
        except Exception as ex:
            logging.error(f"Error processing message: {ex}")

class SolaceDemo:
    def __init__(self, host, port, username, password, vpn_name="default"):
        self.host = host
        self.port = port
        self.username = username
        self.password = password
        self.vpn_name = vpn_name
        self.messaging_service = None
        self.publisher = None
        self.receiver = None

    async def connect(self):
        try:
            # 构建服务配置
            broker_props = {
                "solace.messaging.transport.host": f"tcp://{self.host}:{self.port}",
                "solace.messaging.service.vpn-name": self.vpn_name,
                "solace.messaging.authentication.scheme.basic.username": self.username,
                "solace.messaging.authentication.scheme.basic.password": self.password,
                "solace.messaging.transport.security.strategy": TLS.create().without_certificate_validation()
            }

            # 创建并连接消息服务
            self.messaging_service = MessagingService.builder().from_properties(broker_props).build()
            self.messaging_service.connect()
            logging.info("Successfully connected to Solace")

            # 创建发布者
            self.publisher = self.messaging_service.create_direct_message_publisher_builder().build()
            self.publisher.set_publish_failure_listener(PublishCallback())
            self.publisher.start()
            logging.info("Publisher started")

            # 创建订阅者
            self.receiver = self.messaging_service.create_direct_message_receiver_builder().build()
            self.receiver.start()
            logging.info("Receiver started")

            return True
        except Exception as ex:
            logging.error(f"Failed to connect to Solace: {ex}")
            return False

    async def subscribe(self, topic):
        try:
            if not self.receiver:
                logging.error("Receiver not initialized")
                return False

            subscription = TopicSubscription.of(topic)
            self.receiver.add_subscription(subscription)
            self.receiver.receive_async(SimpleMessageHandler())
            logging.info(f"Subscribed to topic: {topic}")
            return True
        except Exception as ex:
            logging.error(f"Failed to subscribe to topic {topic}: {ex}")
            return False

    async def publish(self, topic, message):
        try:
            if not self.publisher or not self.publisher.is_ready():
                logging.error("Publisher not ready")
                return False

            # 构建消息
            solace_message = self.messaging_service.message_builder() \
                .build(message)

            # 发布消息
            self.publisher.publish(destination=Topic.of(topic), message=solace_message)
            logging.info(f"Published message to topic '{topic}': {message}")
            return True
        except Exception as ex:
            logging.error(f"Failed to publish message: {ex}")
            return False

    async def disconnect(self):
        try:
            if self.publisher:
                self.publisher.terminate()
            if self.receiver:
                self.receiver.terminate()
            if self.messaging_service:
                self.messaging_service.disconnect()
            logging.info("Disconnected from Solace")
        except Exception as ex:
            logging.error(f"Error during disconnect: {ex}")

async def main():
    # 创建SolaceDemo实例
    solace = SolaceDemo(
        host="127.0.0.1",
        port=55555,
        username="admin",
        password="admin",
        vpn_name="default"
    )

    try:
        # 连接到Solace
        if not await solace.connect():
            return

        # 发布一些测试消息
        data = "hello world"
        # 订阅主题
        topic = "flight/boarding/fl1234/yow/ewr"
        await solace.subscribe(topic)
        while True:
            try:
                # 发送消息
                await solace.publish(topic, data)
                await asyncio.sleep(1)
                break
            except KeyboardInterrupt:
                break

    except KeyboardInterrupt:
        logging.info("Shutting down...")
    finally:
        await solace.disconnect()

if __name__ == "__main__":
    asyncio.run(main())

检查日志输出

 检查web界面订阅输出

 可以看到，发布和订阅正常

 

参考资料：

Home | Solace - PubSub+ for Developers

官方github也有一些介绍，可以自行查阅