Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· openaiHugging Face Suzhen/CodeChat

На python сделать менеджер слушателей, которые получают и отдают данные через rabbitmq

  1. User

    На python сделать менеджер слушателей, которые получают и отдают данные через rabbitmq

  2. Assistant

    Для реализации менеджера слушателей на Python, работающего с RabbitMQ, можно использовать библиотеку pika.

    Пример кода:

    import pika
    
    class Listener:
        def __init__(self, url, queue_name):
            self.url = url
            self.queue_name = queue_name
    
        def start(self):
            connection = pika.BlockingConnection(pika.URLParameters(self.url))
            channel = connection.channel()
            channel.queue_declare(queue=self.queue_name)
    
            def callback(ch, method, properties, body):
                # обработка полученных данных
                print("Received message:", body.decode("utf-8"))
    
            channel.basic_consume(queue=self.queue_name, on_message_callback=callback, auto_ack=True)
            print("Listening to queue", self.queue_name)
    
            channel.start_consuming()
    
        def send_message(self, message):
            connection = pika.BlockingConnection(pika.URLParameters(self.url))
            channel = connection.channel()
            channel.queue_declare(queue=self.queue_name)
            channel.basic_publish(exchange="", routing_key=self.queue_name, body=message)
            print("Sent message:", message)
    
            connection.close()
    
    if __name__ == "__main__":
        # пример использования слушателя
        listener = Listener("amqp://guest:guest@localhost:5672/", "test_queue")
        listener.start()
        
        # пример отправки сообщения в очередь
        listener.send_message("Hello, RabbitMQ!")
    

    В данном примере создается класс Listener, который инициализируется URL-адресом сервера RabbitMQ и именем очереди, на которую будут поступать сообщения. Метод start() запускает слушателя, который получает сообщения из очереди и вызывает обработчик callback() для их обработки. Метод send_message() используется для отправки сообщения в очередь.

    Для запуска слушателя достаточно создать экземпляр класса Listener с соответствующими параметрами и вызвать метод start(). Для отправки сообщения можно также использовать метод send_message().

  3. User

    Как запустить несколько таких слушателей из другого скрипта ?

  4. Assistant

    Для запуска нескольких слушателей из другого скрипта можно создать экземпляры класса Listener в цикле и запустить их с помощью многопоточности или многопроцессности.

    Пример использования многопоточности:

    import threading
    from listener import Listener
    
    if __name__ == "__main__":
        urls = ["amqp://guest:guest@localhost:5672/", "amqp://guest:guest@localhost:5672/"]
        queue_names = ["test_queue1", "test_queue2"]
    
        threads = []
    
        for url, queue_name in zip(urls, queue_names):
            listener = Listener(url, queue_name)
            thread = threading.Thread(target=listener.start)
            threads.append(thread)
    
        for thread in threads:
            thread.start()
    
        for thread in threads:
            thread.join()
    

    В данном примере создаются два экземпляра класса Listener для разных URL-адресов и имен очередей. Затем создаются потоки для каждого слушателя и запускаются. Функция join() вызывается для каждого потока, чтобы дождаться их завершения.

    Пример использования многопроцессности:

    import multiprocessing
    from listener import Listener
    
    if __name__ == "__main__":
        urls = ["amqp://guest:guest@localhost:5672/", "amqp://guest:guest@localhost:5672/"]
        queue_names = ["test_queue1", "test_queue2"]
    
        processes = []
    
        for url, queue_name in zip(urls, queue_names):
            listener = Listener(url, queue_name)
            process = multiprocessing.Process(target=listener.start)
            processes.append(process)
    
        for process in processes:
            process.start()
    
        for process in processes:
            process.join()
    

    В данном примере создаются два экземпляра класса Listener и для каждого создается процесс. Затем процессы запускаются функцией start() и ждут своей очереди, чтобы обработать сообщения. Функция join() вызывается для каждого процесса, чтобы дождаться их завершения.

  5. User

    Переделай listener чтобы он мог слушать две очереди и отправлять сообщения в очередь

  6. Assistant

    Для того, чтобы слушать две очереди и отправлять сообщения в одну из них, можно изменить класс Listener следующим образом:

    import pika
    
    class Listener:
        def __init__(self, url, input_queue_name1, input_queue_name2, output_queue_name):
            self.url = url
            self.input_queue_name1 = input_queue_name1
            self.input_queue_name2 = input_queue_name2
            self.output_queue_name = output_queue_name
    
        def start(self):
            connection = pika.BlockingConnection(pika.URLParameters(self.url))
            channel = connection.channel()
    
            # Declare input queues
            channel.queue_declare(queue=self.input_queue_name1)
            channel.queue_declare(queue=self.input_queue_name2)
    
            # Declare output queue
            channel.queue_declare(queue=self.output_queue_name)
    
            def callback1(ch, method, properties, body):
                # обработка полученных данных из первой очереди
                print(f"Received message from {self.input_queue_name1}: {body.decode('utf-8')}")
                # отправить полученное сообщение в выходную очередь
                channel.basic_publish(exchange="", routing_key=self.output_queue_name, body=body)
    
            def callback2(ch, method, properties, body):
                # обработка полученных данных из второй очереди
                print(f"Received message from {self.input_queue_name2}: {body.decode('utf-8')}")
                # отправить полученное сообщение в выходную очередь
                channel.basic_publish(exchange="", routing_key=self.output_queue_name, body=body)
    
            # Subscribe to input queues
            channel.basic_consume(queue=self.input_queue_name1, on_message_callback=callback1, auto_ack=True)
            channel.basic_consume(queue=self.input_queue_name2, on_message_callback=callback2, auto_ack=True)
    
            print(f"Listening to queues {self.input_queue_name1} and {self.input_queue_name2}")
    
            channel.start_consuming()
    
        def send_message(self, message):
            connection = pika.BlockingConnection(pika.URLParameters(self.url))
            channel = connection.channel()
    
            # Declare output queue
            channel.queue_declare(queue=self.output_queue_name)
    
            channel.basic_publish(exchange="", routing_key=self.output_queue_name, body=message)
    
            print(f"Sent message to {self.output_queue_name}: {message}")
    
            connection.close()
    

    Здесь добавлены два параметра - input_queue_name2 для второй очереди и output_queue_name для выходной очереди. В методе start() добавлено определение второй очереди и два колбэка для обработки сообщений из каждой из двух входных очередей. В обоих колбэках добавлена строка отправки полученного сообщения в выходную очередь. В методе send_message() также добавлена отправка сообщения в выходную очередь.

    Для запуска слушателя, нужно создать единственный экземпляр класса Listener, передав ему соответствующие параметры:

    if __name__ == "__main__":
        urls = ["amqp://guest:guest@localhost:5672/"]
        queue_names = ["test_queue1", "test_queue2"]
        output_queue_name = "output_queue"
    
        listener = Listener(urls[0], queue_names[0], queue_names[1], output_queue_name)
        listener.start()
    

    Если нужно использовать несколько серверов RabbitMQ, надо создать соответствующее количество экземпляров класса Listener и запустить их в отдельных потоках или процессах, как показано выше в предыдущих примерах.

  7. User

    Примени dry к listener

  8. Assistant

    Код класса Listener можно улучшить, чтобы сократить дублирование методов и объединить код, который отвечает за подключение к RabbitMQ.

    class Listener:
        def __init__(self, url, input_queue_names, output_queue_name):
            self.url = url
            self.input_queue_names = input_queue_names
            self.output_queue_name = output_queue_name
    
        def start(self):
            def callback(ch, method, properties, body):
                # обработка полученных данных
                queue_name = method.routing_key
                print(f"Received message from {queue_name}: {body.decode('utf-8')}")
                # отправить полученное сообщение в выходную очередь
                channel.basic_publish(exchange="", routing_key=self.output_queue_name, body=body)
    
            with self.get_connection() as connection:
                with connection.channel() as channel:
                    # Declare input queues
                    for queue_name in self.input_queue_names:
                        channel.queue_declare(queue=queue_name)
    
                    # Declare output queue
                    channel.queue_declare(queue=self.output_queue_name)
    
                    # Subscribe to input queues
                    for queue_name in self.input_queue_names:
                        channel.basic_consume(queue=queue_name, on_message_callback=callback, auto_ack=True)
    
                    print(f"Listening to queues {', '.join(self.input_queue_names)}")
    
                    channel.start_consuming()
    
        def send_message(self, message):
            with self.get_connection() as connection:
                with connection.channel() as channel:
                    # Declare output queue
                    channel.queue_declare(queue=self.output_queue_name)
    
                    channel.basic_publish(exchange="", routing_key=self.output_queue_name, body=message)
    
                    print(f"Sent message to {self.output_queue_name}: {message}")
    
        def get_connection(self):
            return pika.BlockingConnection(pika.URLParameters(self.url))
    

    В данной версии класса Listener были объединены методы start() для подключения к очередям и send_message() для отправки сообщений в выходную очередь. Теперь эти два метода используют общий метод get_connection() для получения соединения с сервером RabbitMQ.

    Также добавлена переменная input_queue_names, которая хранит список имен всех входных очередей. Теперь вместо создания нескольких колбэков для каждой очереди, мы создаем единый колбэк, который определяет, из какой очереди пришло сообщение и отправляет его в выходную очередь.

    Теперь класс Listener более гибок и можно использовать его для слушания и отправки сообщений из и в несколько очередей.

  9. User

    Доработай чтобы список очередей подгружались из бд

  10. Assistant

    Чтобы получать список входных очередей из базы данных, можно использовать библиотеку SQLAlchemy.

    Во-первых, нужно создать таблицу в базе данных, которая будет хранить имена очередей.

    from sqlalchemy import Column, Integer, String
    from sqlalchemy.ext.declarative import declarative_base
    
    Base = declarative_base()
    
    class Queue(Base):
        __tablename__ = 'queues'
    
        id = Column(Integer, primary_key=True)
        name = Column(String)
    

    Здесь определена таблица "queues", которая хранит идентификатор и имя очереди.

    Далее, нужно изменить конструктор класса Listener, чтобы он получал URL и имя выходной очереди и использовал SQLAlchemy для получения списка имен входных очередей из базы данных.

    from sqlalchemy import create_engine
    from sqlalchemy.orm import sessionmaker
    
    class Listener:
        def __init__(self, url, output_queue_name):
            self.url = url
            self.output_queue_name = output_queue_name
            engine = create_engine('sqlite:///queues.db')
            Base.metadata.create_all(engine)
            Session = sessionmaker(bind=engine)
            session = Session()
            self.input_queue_names = [queue.name for queue in session.query(Queue).all()]
    
        # ... остальной код
    

    Здесь создаются соединение с базой данных и объект сессии для выполнения запросов. Затем получается список всех записей из таблицы "queues" и заполняется список имен входных очередей.

    Теперь можно создать экземпляр класса Listener, передав ему URL-адрес сервера RabbitMQ и имя выходной очереди:

    if __name__ == "__main__":
        url = "amqp://guest:guest@localhost:5672/"
        output_queue_name = "output_queue"
        listener = Listener(url, output_queue_name)
        listener.start()
    

    Теперь класс Listener использует список входных очередей, полученный из базы данных, и запускает слушатель для каждой очереди в этом списке.

  11. User

    Вынеси логику работы с бд отдельно

  12. Assistant

    Для вынесения логики работы с базой данных из класса Listener можно создать отдельный класс QueueDatabase и передавать экземпляр этого класса в конструктор класса Listener.

    from sqlalchemy import create_engine
    from sqlalchemy.orm import sessionmaker
    
    class QueueDatabase:
        def __init__(self, db_url):
            self.engine = create_engine(db_url)
            Base.metadata.create_all(self.engine)
            Session = sessionmaker(bind=self.engine)
            self.session = Session()
    
        def get_queue_names(self):
            return [queue.name for queue in self.session.query(Queue).all()]
    
    class Listener:
        def __init__(self, url, output_queue_name, queue_db):
            self.url = url
            self.output_queue_name = output_queue_name
            self.input_queue_names = queue_db.get_queue_names()
    
        # ... остальной код
    

    Здесь создается отдельный класс QueueDatabase, который инициализируется URL-адресом бд, создает соединение с базой и объявляет объект сессии. Метод get_queue_names() возвращает список имен всех очередей из базы.

    В классе Listener, в методе __init__(), передается экземпляр класса QueueDatabase в качестве аргумента. Метод get_queue_names() используется для получения списка входных очередей.

    Для применения класса можно создать экземпляры Listener и QueueDatabase следующим образом:

    if __name__ == "__main__":
        url = "amqp://guest:guest@localhost:5672/"
        output_queue_name = "output_queue"
        db_url = "sqlite:///queues.db"
        queue_db = QueueDatabase(db_url)
        listener = Listener(url, output_queue_name, queue_db)
        listener.start()
    

    Таким образом, класс Listener не знает о деталях реализации работы с базой данных, а класс QueueDatabase инкапсулирует в себе логику работы с бд.