Merge pull request 'kochkareva_elizaveta_lab_4 is ready' (#148) from kochkareva_elizaveta_lab_4 into main

Reviewed-on: #148

kochkareva_elizaveta_lab_4/README.md

@@ -0,0 +1,190 @@
+
+# Лабораторная работа 4. 
+
+### Задание
+**Цель**: изучение проектирования приложений при помощи брокера сообщений.
+
+**Задачи**:
+
+- Установить брокер сообщений RabbitMQ.
+- Пройти уроки 1, 2 и 3 из RabbitMQ Tutorials на любом языке программирования.
+- Продемонстрировать работу брокера сообщений.
+
+### Как запустить лабораторную работу
+В директории с файлом характеристик docker-compose.yaml выполнить команду:
+```
+docker-compose -f docker-compose.yaml up
+```
+### Описание лабораторной работы
+#### Прохождение tutorial
+
+**1. *"Hello world"***
+
+Результат работы producer:
+![Сборка docker-compose](hello-world-send.jpg)
+
+Результат работы consumer:
+![Сборка docker-compose](hello-world-receive.jpg)
+
+
+**2. *"Work Queues"***
+
+Результат работы producer:
+![Сборка docker-compose](work-queues-new-task.jpg)
+
+Результат работы consumer:
+![Сборка docker-compose](work-queues-worker.jpg)
+
+**3. *"Publish/Subscribe"***
+
+Результат работы producer:
+![Сборка docker-compose](publish-subscribe-emit-log.jpg)
+
+Результат работы consumer1:
+![Сборка docker-compose](publish-subscribe-receive-logs1.jpg)
+
+Результат работы consumer2:
+![Сборка docker-compose](publish-subscribe-receive-logs2.jpg)
+
+
+#### Разработка демонстрационных приложений
+Для разработки демонстрационных приложений была выбрана предметная область прошлой лабораторной  работы, состоящая из тренировок и упражнений.
+
+Согласно заданию необходимо создать:
+1. Publisher, которая создаёт один exchange с типом fanout.
+
+Для этого создадим список logs, который хранит различные сообщения логов, которые могут быть отправлены.
+
+```python
+logs = ["started exercise", "finished exercise", "started training", "finished training"]
+```
+
+Установим соединение с локальным *RabbitMQ* сервером на `localhost` и создадим канал связи с *RabbitMQ* для отправки и получения сообщений.
+
+```python
+connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
+channel = connection.channel()
+```
+
+Далее определим имя обмена в *RabbitMQ*, в данном случае logs и объявем обмен с указанным именем и типом fanout, что означает, что все сообщения, отправленные в этот обмен, будут отправлены всем подписчикам, которые присоединены к нему.
+```python
+exchange_name = 'logs'
+channel.exchange_declare(exchange=exchange_name, exchange_type='fanout')
+```
+
+Для того, чтобы программа раз в секунду генерировала сообщения в журнал событий создадим цикл, в котором будет выбираться случайное сообщение из списка `logs`, публиковаться в обмен `logs` без указания ключа маршрутизации (сообщение будет доставлено всем подписчикам этого обмена). И также укажем задержку в 1 секунду между каждой публикацией сообщения.
+```python
+while 1:
+    log = random.choice(logs)
+    channel.basic_publish(exchange=exchange_name, routing_key='', body=log)
+    print(f" [x] Published: {log}")
+    time.sleep(1)
+```
+
+2. Consumer 1, которая создаёт под себя отдельную не анонимную очередь, создаёт binding на exchange и начинает принимать сообщения. Программа должна обрабатывать сообщения 2-3 секунды.
+
+Создадим функцию `message_manager`, которая принимает три аргумента: `channel` (канал связи с RabbitMQ), `queue_name` (имя очереди) и `exchange_name` (имя обмена).
+Затем объявляем очеред с указанным именем, связываем очередь с обменом, чтобы сообщения из этого обмена были доставлены в эту очередь.
+
+Также создаем функцию `callback`, которая будет вызываться при получении нового сообщения из очереди. В данной функции происходит декодирование полученного сообщения из байтового формата в строку, вывод результата в консоль и имитация обработки сообщения с помощью задержки сообщения на 2-3 секунды. В зависимости от полученного значения декодированого сообщения, происходит вывод сообщение о статусе обработки, а также происходит подтверждение успешной обработки сообщения.
+
+```python
+    def callback(ch, method, properties, body):
+        task = body.decode()
+        print(f" [x] Received : {task}")
+        time.sleep(random.randint(2, 3))
+        if task == "started exercise":
+            print(" [x] Started timer")
+        elif task == "finished exercise":
+            print(" [x] Stopped timer, started another exercise")
+        elif task == "started training":
+            print(" [x] Started manage exercise")
+        else:
+            print(" [x] Result of training given")
+        ch.basic_ack(delivery_tag=method.delivery_tag)
+```
+
+Далее устанавливаем обработчик callback для сообщений из указанной очереди и запускаем  бесконечный цикл получения и обработки сообщений из очереди.
+Таким образом, функция `message_manager` выглядет следующим образом:
+
+```python
+def message_manager(channel, queue_name, exchange_name):
+    channel.queue_declare(queue=queue_name)
+    channel.queue_bind(exchange=exchange_name, queue=queue_name)
+
+    def callback(ch, method, properties, body):
+        task = body.decode()
+        print(f" [x] Received : {task}")
+        time.sleep(random.randint(2, 3))
+        if task == "started exercise":
+            print(" [x] Started timer")
+        elif task == "finished exercise":
+            print(" [x] Stopped timer, started another exercise")
+        elif task == "started training":
+            print(" [x] Started manage exercise")
+        else:
+            print(" [x] Result of training given")
+        ch.basic_ack(delivery_tag=method.delivery_tag)
+
+    channel.basic_consume(queue=queue_name, on_message_callback=callback)
+    print("[*] Waiting for messages. To exit press CTRL+C")
+    channel.start_consuming()
+```
+
+Далее создаем соединение с *RabbitMQ*, создаем канал и определяем имя обмена и имя очереди. Затем, создаем поток `consumer_thread`, который вызывает функцию `message_manager` с передачей канала, имени очереди и имени обмена в качестве аргументов. После этого, поток запускается и ожидает его завершения с помощью `consumer_thread.join()`, чтобы основной поток программы не завершился до завершения работы обработчика сообщений.
+
+```python
+connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
+channel = connection.channel()
+exchange_name = 'logs'
+queue_name = 'slow-queue'
+
+consumer_thread = threading.Thread(target=message_manager, args=(channel, queue_name, exchange_name))
+consumer_thread.start()
+consumer_thread.join()
+```
+
+
+3. Consumer 2. Аналогично Consumer 1, только сообщения необходимо обрабатывать моментально и имя очереди должно отличаться от Consumer 1.
+
+Аналогично создаем подключение к серверу  с помощью `pika.BlockingConnection`,создаем канал для обмена сообщениями с помощью `connection.channel()`. Определяем имя обменника *"logs"* и имя очереди *"fast-queue"*. Далее объявляем саму очередь с данным именем. 
+
+```python
+connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
+channel = connection.channel()
+exchange_name = 'logs'
+queue_name = 'fast-queue'
+
+channel.queue_declare(queue=queue_name)
+channel.queue_bind(exchange=exchange_name, queue=queue_name)
+```
+
+После чего создаем функцию `callback`, которая будет вызываться при получении сообщений из очереди. Функция принимает параметры `ch` (канал), `method` (метод доставки), `properties` (свойства сообщения) и `body` (тело сообщения). В данном случае, функция аналогично декодирует тело сообщения в строку и выводит соответствующее сообщение в зависимости от значения `task`.
+```python
+def callback(ch, method, properties, body):
+    task = body.decode()
+    print(f" [x] Received : {task}")
+    if task == "started exercise":
+        print(" [x] Started timer")
+    elif task == "finished exercise":
+        print(" [x] Stopped timer, started another exercise")
+    elif task == "started training":
+        print(" [x] Started manage exercise")
+    else:
+        print(" [x] Result of training given")
+    ch.basic_ack(delivery_tag=method.delivery_tag)
+
+```
+Код будет ожидать и обрабатывать сообщения, пока не будет прерван.
+
+Результат работы быстрой очереди:
+![Сборка docker-compose](fast-queue.jpg)
+
+Результат работы медленной очереди:
+![Сборка docker-compose](slow-queue.jpg)
+
+Таким образом, можно сделать вывод о том, что в очереди fast-queue сообщения обрабатываются мгновенно, а в очереди slow-queue они обрабатываются с задержкой и в следствии этого сообщения накапливаются в очереди.
+
+### Видео 
+
+https://disk.yandex.ru/i/Qei-5DvhovOBJA

kochkareva_elizaveta_lab_4/exercise-training/consumer-1.py

@@ -0,0 +1,37 @@
+import pika
+import random
+import threading
+import time
+
+
+def message_manager(channel, queue_name, exchange_name):
+    channel.queue_declare(queue=queue_name)
+    channel.queue_bind(exchange=exchange_name, queue=queue_name)
+
+    def callback(ch, method, properties, body):
+        task = body.decode()
+        print(f" [x] Received : {task}")
+        time.sleep(random.randint(2, 3))
+        if task == "started exercise":
+            print(" [x] Started timer")
+        elif task == "finished exercise":
+            print(" [x] Stopped timer, started another exercise")
+        elif task == "started training":
+            print(" [x] Started manage exercise")
+        else:
+            print(" [x] Result of training given")
+        ch.basic_ack(delivery_tag=method.delivery_tag)
+
+    channel.basic_consume(queue=queue_name, on_message_callback=callback)
+    print("[*] Waiting for messages. To exit press CTRL+C")
+    channel.start_consuming()
+
+
+connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
+channel = connection.channel()
+exchange_name = 'logs'
+queue_name = 'slow-queue'
+
+consumer_thread = threading.Thread(target=message_manager, args=(channel, queue_name, exchange_name))
+consumer_thread.start()
+consumer_thread.join()

kochkareva_elizaveta_lab_4/exercise-training/consumer-2.py

@@ -0,0 +1,28 @@
+import pika
+
+connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
+channel = connection.channel()
+exchange_name = 'logs'
+queue_name = 'fast-queue'
+
+channel.queue_declare(queue=queue_name)
+channel.queue_bind(exchange=exchange_name, queue=queue_name)
+
+
+def callback(ch, method, properties, body):
+    task = body.decode()
+    print(f" [x] Received : {task}")
+    if task == "started exercise":
+        print(" [x] Started timer")
+    elif task == "finished exercise":
+        print(" [x] Stopped timer, started another exercise")
+    elif task == "started training":
+        print(" [x] Started manage exercise")
+    else:
+        print(" [x] Result of training given")
+    ch.basic_ack(delivery_tag=method.delivery_tag)
+
+
+channel.basic_consume(queue=queue_name, on_message_callback=callback)
+print("[*] Waiting for messages. To exit press CTRL+C")
+channel.start_consuming()

kochkareva_elizaveta_lab_4/exercise-training/publisher.py

@@ -0,0 +1,17 @@
+import pika
+import random
+import time
+
+logs = ["started exercise", "finished exercise", "started training", "finished training"]
+
+connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
+channel = connection.channel()
+exchange_name = 'logs'
+channel.exchange_declare(exchange=exchange_name, exchange_type='fanout')
+print(' [*] Started. To exit press CTRL+C')
+
+while 1:
+    log = random.choice(logs)
+    channel.basic_publish(exchange=exchange_name, routing_key='', body=log)
+    print(f" [x] Published: {log}")
+    time.sleep(1)

kochkareva_elizaveta_lab_4/hello-world/receive.py

@@ -0,0 +1,30 @@
+import os
+import pika
+import sys
+
+
+def main():
+    connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
+    channel = connection.channel()
+
+    channel.queue_declare(queue='hello')
+
+    def callback(ch, method, properties, body):
+        print(f" [x] Received {body}")
+
+    channel.basic_consume(queue='hello', on_message_callback=callback, auto_ack=True)
+
+    print(' [*] Waiting for messages. To exit press CTRL+C')
+    channel.start_consuming()
+
+
+if __name__ == '__main__':
+    try:
+        main()
+    except KeyboardInterrupt:
+        print('Interrupted')
+        try:
+            sys.exit(0)
+        except SystemExit:
+            os._exit(0)
+

kochkareva_elizaveta_lab_4/hello-world/send.py

@@ -0,0 +1,11 @@
+import pika
+
+connection = pika.BlockingConnection(
+    pika.ConnectionParameters(host='localhost'))
+channel = connection.channel()
+
+channel.queue_declare(queue='hello')
+
+channel.basic_publish(exchange='', routing_key='hello', body='Hello World!')
+print(" [x] Sent 'Hello World!'")
+connection.close()

kochkareva_elizaveta_lab_4/publish-subscribe/emit_log.py

@@ -0,0 +1,13 @@
+import pika
+import sys
+
+connection = pika.BlockingConnection(
+    pika.ConnectionParameters(host='localhost'))
+channel = connection.channel()
+
+channel.exchange_declare(exchange='logs', exchange_type='fanout')
+
+message = ' '.join(sys.argv[1:]) or "info: Hello World!"
+channel.basic_publish(exchange='logs', routing_key='', body=message)
+print(f" [x] Sent {message}")
+connection.close()

kochkareva_elizaveta_lab_4/publish-subscribe/receive_logs.py

@@ -0,0 +1,22 @@
+import pika
+
+connection = pika.BlockingConnection(
+    pika.ConnectionParameters(host='localhost'))
+channel = connection.channel()
+
+channel.exchange_declare(exchange='logs', exchange_type='fanout')
+
+result = channel.queue_declare(queue='', exclusive=True)
+queue_name = result.method.queue
+
+channel.queue_bind(exchange='logs', queue=queue_name)
+
+print(' [*] Waiting for logs. To exit press CTRL+C')
+
+def callback(ch, method, properties, body):
+    print(f" [x] {body}")
+
+channel.basic_consume(
+    queue=queue_name, on_message_callback=callback, auto_ack=True)
+
+channel.start_consuming()

kochkareva_elizaveta_lab_4/work-queues/new_task.py

@@ -0,0 +1,20 @@
+import pika
+import sys
+
+connection = pika.BlockingConnection(
+    pika.ConnectionParameters(host='localhost'))
+channel = connection.channel()
+
+channel.queue_declare(queue='task_queue', durable=True)
+
+message = ' '.join(sys.argv[1:]) or "Hello World!"
+channel.basic_publish(
+    exchange='',
+    routing_key='task_queue',
+    body=message,
+    properties=pika.BasicProperties(
+        delivery_mode=pika.DeliveryMode.Persistent
+    ))
+print(f" [x] Sent {message}")
+connection.close()
+

kochkareva_elizaveta_lab_4/work-queues/worker.py

@@ -0,0 +1,23 @@
+import pika
+import time
+
+connection = pika.BlockingConnection(
+    pika.ConnectionParameters(host='localhost'))
+channel = connection.channel()
+
+channel.queue_declare(queue='task_queue', durable=True)
+print(' [*] Waiting for messages. To exit press CTRL+C')
+
+
+def callback(ch, method, properties, body):
+    print(f" [x] Received {body.decode()}")
+    time.sleep(body.count(b'.'))
+    print(" [x] Done")
+    ch.basic_ack(delivery_tag=method.delivery_tag)
+
+
+channel.basic_qos(prefetch_count=1)
+channel.basic_consume(queue='task_queue', on_message_callback=callback)
+
+channel.start_consuming()
+