Compare commits
No commits in common. "main" and "mochalov_danila_lab_2" have entirely different histories.
main
...
mochalov_d
3
dozorova_alena_lab_6/.gitignore → .gitignore
vendored
3
dozorova_alena_lab_6/.gitignore → .gitignore
vendored
@ -7,6 +7,3 @@
|
||||
/dozorova_alena_lab_2/ConsoleApp2/.vs
|
||||
/dozorova_alena_lab_2/ConsoleApp2/bin
|
||||
/dozorova_alena_lab_2/ConsoleApp2/obj
|
||||
/dozorova_alena_lab_6/ConsoleApp1/.vs
|
||||
/dozorova_alena_lab_6/ConsoleApp1/bin
|
||||
/dozorova_alena_lab_6/ConsoleApp1/obj
|
||||
@ -1 +0,0 @@
|
||||
main.py
|
||||
@ -1,12 +0,0 @@
|
||||
<component name="InspectionProjectProfileManager">
|
||||
<profile version="1.0">
|
||||
<option name="myName" value="Project Default" />
|
||||
<inspection_tool class="PyUnresolvedReferencesInspection" enabled="true" level="WARNING" enabled_by_default="true">
|
||||
<option name="ignoredIdentifiers">
|
||||
<list>
|
||||
<option value="str.__pos__" />
|
||||
</list>
|
||||
</option>
|
||||
</inspection_tool>
|
||||
</profile>
|
||||
</component>
|
||||
@ -1,6 +0,0 @@
|
||||
<component name="InspectionProjectProfileManager">
|
||||
<settings>
|
||||
<option name="USE_PROJECT_PROFILE" value="false" />
|
||||
<version value="1.0" />
|
||||
</settings>
|
||||
</component>
|
||||
@ -1,4 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="ProjectRootManager" version="2" project-jdk-name="Python 3.9 (tukaeva_alfiya_lab_4)" project-jdk-type="Python SDK" />
|
||||
</project>
|
||||
@ -1,32 +0,0 @@
|
||||
# Лабораторная работа 1 - Знакомство с Docker и Docker Compose
|
||||
## ПИбд-42 || Алейкин Артем
|
||||
|
||||
### Описание
|
||||
В данной лабораторной работе мы разворачиваем три популярных сервиса — MediaWiki и Redmine — с использованием Docker Compose. Каждый сервис работает в своем контейнере и использует общую базу данных PostgreSQL для хранения данных. Мы также настраиваем проброс портов для доступа к веб-интерфейсам сервисов и используем Docker volumes для сохранения данных вне контейнеров.
|
||||
|
||||
### Цель проекта
|
||||
изучение современных технологий контейнеризации
|
||||
|
||||
### Шаги для запуска:
|
||||
1. Клонирование репозитория:
|
||||
```
|
||||
git clone <ссылка-на-репозиторий>
|
||||
cd <папка репозитория>
|
||||
```
|
||||
|
||||
2. Запуск контейнеров:
|
||||
```
|
||||
docker-compose up -d
|
||||
```
|
||||
|
||||
3. После запуска должны быть доступны следующие контейнеры:
|
||||
|
||||
MediaWiki: http://localhost:8080
|
||||
Redmine: http://localhost:8081
|
||||
|
||||
4. Чтобы остановить контейнеры:
|
||||
```
|
||||
docker-compose down
|
||||
```
|
||||
|
||||
Видео демонстрации работы: https://vk.com/video248424990_456239601?list=ln-sCRa9IIiV1VpInn2d1
|
||||
@ -1,45 +0,0 @@
|
||||
services:
|
||||
mediawiki:
|
||||
image: mediawiki
|
||||
container_name: mediawiki
|
||||
ports:
|
||||
- "8080:80" # Пробрасываем порт 8080 на хост для доступа к MediaWiki
|
||||
volumes:
|
||||
- mediawiki_data:/var/www/html/images # Создаем volume для хранения данных MediaWiki
|
||||
environment:
|
||||
- MEDIAWIKI_DB_HOST=db
|
||||
- MEDIAWIKI_DB_NAME=mediawiki
|
||||
- MEDIAWIKI_DB_USER=root
|
||||
- MEDIAWIKI_DB_PASSWORD=example
|
||||
depends_on:
|
||||
- db
|
||||
|
||||
redmine:
|
||||
image: redmine
|
||||
container_name: redmine
|
||||
ports:
|
||||
- "8081:3000" # Пробрасываем порт 8081 на хост для доступа к Redmine
|
||||
volumes:
|
||||
- redmine_data:/usr/src/redmine/files # Создаем volume для хранения данных Redmine
|
||||
environment:
|
||||
- REDMINE_DB_POSTGRESQL=db
|
||||
- REDMINE_DB_DATABASE=redmine
|
||||
- REDMINE_DB_USERNAME=root
|
||||
- REDMINE_DB_PASSWORD=example
|
||||
depends_on:
|
||||
- db
|
||||
|
||||
db:
|
||||
image: postgres:latest
|
||||
container_name: db
|
||||
environment:
|
||||
POSTGRES_USER: postgres
|
||||
POSTGRES_PASSWORD: example
|
||||
POSTGRES_DB: postgres
|
||||
volumes:
|
||||
- db_data:/var/lib/postgresql # Volume для базы данных
|
||||
|
||||
volumes:
|
||||
mediawiki_data: # volume для MediaWiki
|
||||
redmine_data: # volume для Redmine
|
||||
db_data: # volume для базы данных
|
||||
@ -1,48 +0,0 @@
|
||||
## Отчет по Docker Compose конфигурации
|
||||
|
||||
### Краткое описание:
|
||||
|
||||
Данная конфигурация Docker Compose запускает набор сервисов, необходимых для работы WordPress и MediaWiki. Она включает в себя:
|
||||
|
||||
- **WordPress:** веб-сервис для блогов и CMS
|
||||
- **MySQL:** база данных для хранения данных WordPress
|
||||
- **RabbitMQ:** брокер сообщений для потенциального использования в будущем
|
||||
- **MediaWiki:** вики-движок для создания и редактирования вики-страниц
|
||||
|
||||
### Запуск лабораторной работы:
|
||||
|
||||
1. Установить Docker и Docker Compose.
|
||||
2. Сохранить конфигурацию в файл docker-compose.yml.
|
||||
3. Запустить команду docker-compose up --build
|
||||
|
||||
### Используемые технологии:
|
||||
|
||||
- **Docker Compose:** инструмент для определения и запуска многоконтейнерных приложений.
|
||||
- **Docker:** платформа для создания, развертывания и запуска контейнеров.
|
||||
- **WordPress:** популярная платформа для создания блогов и CMS.
|
||||
- **MySQL:** популярная система управления базами данных.
|
||||
- **RabbitMQ:** брокер сообщений, используемый для асинхронного обмена сообщениями.
|
||||
- **MediaWiki:** свободное программное обеспечение для создания и редактирования вики-страниц.
|
||||
|
||||
### Функциональность:
|
||||
|
||||
Конфигурация запускает следующие сервисы:
|
||||
|
||||
- **WordPress:** работает на порту 8080, доступен по адресу http://localhost:8080.
|
||||
- **MySQL:** предоставляет базу данных для WordPress и MediaWiki.
|
||||
- **RabbitMQ:** работает на порту 5672, доступен по адресу http://localhost:15672 для управления.
|
||||
- **MediaWiki:** работает на порту 8081, доступен по адресу http://localhost:8081.
|
||||
|
||||
### Дополнительные сведения
|
||||
|
||||
- **Volumes**: используются для хранения данных сервисов, чтобы они не терялись при перезапуске контейнеров.
|
||||
- **Depends_on**: указывает на зависимость между сервисами, например, WordPress зависит от MySQL.
|
||||
- **Restart policy**: определяет, как сервисы будут перезапускаться после сбоя.
|
||||
|
||||
### Видео
|
||||
|
||||
https://vk.com/video/@artamonovat?z=video212084908_456239356%2Fpl_212084908_-2
|
||||
|
||||
### Заключение:
|
||||
|
||||
Данная конфигурация Docker Compose обеспечивает простой и удобный способ запуска и управления несколькими сервисами, связанными с WordPress и MediaWiki. Она позволяет разработчикам легко развертывать и управлять приложениями в изолированной среде.
|
||||
@ -1,61 +0,0 @@
|
||||
version: '3.7'
|
||||
|
||||
services:
|
||||
wordpress:
|
||||
image: wordpress:latest
|
||||
ports:
|
||||
- "8080:80"
|
||||
volumes:
|
||||
- wordpress_data:/var/www/html
|
||||
environment:
|
||||
WORDPRESS_DB_HOST: db
|
||||
WORDPRESS_DB_NAME: wordpress
|
||||
WORDPRESS_DB_USER: wordpress
|
||||
WORDPRESS_DB_PASSWORD: password
|
||||
depends_on:
|
||||
- db
|
||||
restart: unless-stopped
|
||||
|
||||
db:
|
||||
image: mysql:latest
|
||||
volumes:
|
||||
- db_data:/var/lib/mysql
|
||||
environment:
|
||||
MYSQL_DATABASE: wordpress
|
||||
MYSQL_USER: wordpress
|
||||
MYSQL_PASSWORD: dbpassword
|
||||
MYSQL_ROOT_PASSWORD: rootpassword
|
||||
restart: unless-stopped
|
||||
|
||||
rabbitmq:
|
||||
image: rabbitmq:3-management
|
||||
ports:
|
||||
- "5672:5672"
|
||||
- "15672:15672"
|
||||
volumes:
|
||||
- rabbitmq_data:/var/lib/rabbitmq
|
||||
environment:
|
||||
RABBITMQ_DEFAULT_USER: guest
|
||||
RABBITMQ_DEFAULT_PASS: password
|
||||
restart: unless-stopped
|
||||
|
||||
mediawiki:
|
||||
image: mediawiki:latest
|
||||
ports:
|
||||
- "8081:80"
|
||||
volumes:
|
||||
- mediawiki_data:/var/www/html
|
||||
environment:
|
||||
MW_DB_SERVER: db
|
||||
MW_DB_NAME: mediawiki
|
||||
MW_DB_USER: mediawiki
|
||||
MW_DB_PASSWORD: mediawiki_password
|
||||
depends_on:
|
||||
- db
|
||||
restart: unless-stopped
|
||||
|
||||
volumes:
|
||||
wordpress_data:
|
||||
db_data:
|
||||
rabbitmq_data:
|
||||
mediawiki_data:
|
||||
5
artamonova_tatyana_lab_2/.gitignore
vendored
5
artamonova_tatyana_lab_2/.gitignore
vendored
@ -1,5 +0,0 @@
|
||||
*.pyc
|
||||
__pycache__
|
||||
*.egg-info
|
||||
*.dist-info
|
||||
.DS_Store
|
||||
@ -1,22 +0,0 @@
|
||||
## Лабораторная работа №2
|
||||
### Выполнила Артамонова Татьяна ПИбд-42
|
||||
|
||||
**Вариант 1: Программа 4 - Количество символов в именах файлов из каталога /var/data**
|
||||
|
||||
- Формирует файл /var/result/data1.txt так, что каждая строка файла - количество символов в именах файлов из каталога /var/data.
|
||||
|
||||
**Вариант 2: Программа 3 - Количество чисел в последовательности**
|
||||
|
||||
- Ищет набольшее число из файла /var/result/data1.txt и сохраняет количество таких чисел из последовательности в /var/result/data2.txt.
|
||||
|
||||
**Структура проекта:**
|
||||
|
||||
1. В папках worker-1, worker-2 лежат выполняемые файлы .py и Dockerfile-ы с необходимым набором инструкций.
|
||||
2. В папке data лежат файлы, длину имен которых нужно посчитать.
|
||||
3. В папке result лежат файлы с результатами выполнения программ. data1.txt - результат выполнения main1.py (worker-1), data2.txt - результат выполнения main2.py (worker-2). Данные в data2 рассчитываются из данных data1.
|
||||
4. Файл .gitignore - для указания, какие файлы отслеживать, а какие - нет.
|
||||
5. docker-compose.yml - для определения и управления контейнерами Docker.
|
||||
|
||||
**Команда для запуска** - docker-compose up --build
|
||||
|
||||
**Ссылка на видео:** https://vk.com/artamonovat?z=video212084908_456239357%2Fvideos212084908%2Fpl_212084908_-2
|
||||
@ -1,22 +0,0 @@
|
||||
services:
|
||||
worker-1:
|
||||
build:
|
||||
context: ./worker-1
|
||||
volumes:
|
||||
- ./worker-1:/app
|
||||
- ./data:/var/data
|
||||
- ./result:/var/result
|
||||
depends_on:
|
||||
- worker-2
|
||||
|
||||
worker-2:
|
||||
build:
|
||||
context: ./worker-2
|
||||
volumes:
|
||||
- ./worker-2:/app
|
||||
- ./data:/var/data
|
||||
- ./result:/var/result
|
||||
|
||||
volumes:
|
||||
data:
|
||||
result:
|
||||
@ -1,3 +0,0 @@
|
||||
15
|
||||
18
|
||||
18
|
||||
@ -1 +0,0 @@
|
||||
2
|
||||
@ -1,14 +0,0 @@
|
||||
# Используем образ Python 3.10-slim как основу для нашего контейнера.
|
||||
# slim-версия образа более компактная, что делает контейнер меньше.
|
||||
FROM python:3.10-slim
|
||||
|
||||
# Устанавливаем рабочую директорию в контейнере как /app.
|
||||
# Все последующие команды будут выполняться в этой директории.
|
||||
WORKDIR /app
|
||||
|
||||
# Копируем файл main1.py из текущей директории в директорию /app в контейнере.
|
||||
COPY main1.py .
|
||||
|
||||
# Определяем команду, которая будет выполняться при запуске контейнера.
|
||||
# В данном случае запускается Python-скрипт main1.py.
|
||||
CMD ["python", "main1.py"]
|
||||
@ -1,21 +0,0 @@
|
||||
import os
|
||||
import glob
|
||||
|
||||
# Формирует файл data1.txt так, что каждая строка файла - кол-во символов в именах файла из каталога /data
|
||||
def main():
|
||||
data_dir = "/var/data"
|
||||
result_file = "/var/result/data1.txt"
|
||||
|
||||
result_dir = os.path.dirname(result_file)
|
||||
if not os.path.exists(result_dir):
|
||||
os.makedirs(result_dir)
|
||||
|
||||
files = glob.glob(os.path.join(data_dir, '*'))
|
||||
|
||||
with open(result_file, 'w') as f:
|
||||
for file in files:
|
||||
filename = os.path.basename(file)
|
||||
f.write(f"{len(filename)}\n")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -1,14 +0,0 @@
|
||||
# Используем образ Python 3.10-slim как основу для нашего контейнера.
|
||||
# slim-версия образа более компактная, что делает контейнер меньше.
|
||||
FROM python:3.10-slim
|
||||
|
||||
# Устанавливаем рабочую директорию в контейнере как /app.
|
||||
# Все последующие команды будут выполняться в этой директории.
|
||||
WORKDIR /app
|
||||
|
||||
# Копируем файл main2.py из текущей директории в директорию /app в контейнере.
|
||||
COPY main2.py .
|
||||
|
||||
# Определяем команду, которая будет выполняться при запуске контейнера.
|
||||
# В данном случае запускается Python-скрипт main2.py.
|
||||
CMD ["python", "main2.py"]
|
||||
@ -1,26 +0,0 @@
|
||||
import os
|
||||
|
||||
# Ищет наибольшее число из файла data1.txt и сохраняет количество таких чисел из последовательности в data2.txt
|
||||
def main():
|
||||
data_file_path = "/var/result/data1.txt"
|
||||
result_file_path = "/var/result/data2.txt"
|
||||
|
||||
if not os.path.exists(data_file_path):
|
||||
data_dir = os.path.dirname(data_file_path)
|
||||
|
||||
if not os.path.exists(result_file_path):
|
||||
result_dir = os.path.dirname(result_file_path)
|
||||
|
||||
with open(data_file_path, 'r') as f:
|
||||
numbers = [int(x.strip()) for x in f.read().splitlines()]
|
||||
|
||||
max_number = max(numbers)
|
||||
count = numbers.count(max_number)
|
||||
|
||||
with open(result_file_path, 'w') as f:
|
||||
f.write(str(count))
|
||||
|
||||
print(f"Количество наибольших чисел: {count}")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -1,6 +1,11 @@
|
||||
# Распределенные вычисления и приложения Л3
|
||||
# Распределенные вычисления и приложения Л2
|
||||
## _Автор Базунов Андрей Игревич ПИбд-42_
|
||||
|
||||
Сервисы ( _порядок исполнения сервисов соблюден_ ):
|
||||
- 1.FileCreator - (_Создание тестовых данных_)
|
||||
- 2.FirstService - (_Выполнение 1.4 варианта задания_)
|
||||
- 3.SecondService - (_Выполнение 2.2 варианта задания_)
|
||||
|
||||
В качестве основного языка был выбран GoLang. Для каждого сервиса был создан DOCKERFILE где были прописаны условия и действия для сборки каждого из модулей
|
||||
|
||||
# Docker
|
||||
@ -22,4 +27,4 @@ docker-compose up -d --build
|
||||
docker-compose down
|
||||
```
|
||||
|
||||
[Демонстрация работы](https://vk.com/video/@viltskaa?z=video236673313_456239577%2Fpl_236673313_-2)
|
||||
[Демонстрация работы](https://vk.com/video236673313_456239575)
|
||||
BIN
bazunov_andrew_lab_3/PersonApp/.DS_Store
vendored
BIN
bazunov_andrew_lab_3/PersonApp/.DS_Store
vendored
Binary file not shown.
@ -1,4 +0,0 @@
|
||||
PORT=8080
|
||||
TASK_APP_URL=http://task-app:8000
|
||||
TIMEOUT=15
|
||||
DATABASE=./database.db
|
||||
@ -1,14 +0,0 @@
|
||||
FROM golang:1.23
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
COPY go.mod go.sum ./
|
||||
RUN go mod download
|
||||
|
||||
COPY . .
|
||||
|
||||
RUN go build -o /bin/PersonApp
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
CMD ["/bin/PersonApp"]
|
||||
Binary file not shown.
@ -1,10 +0,0 @@
|
||||
module PersonApp
|
||||
|
||||
go 1.23.1
|
||||
|
||||
require (
|
||||
github.com/gorilla/mux v1.8.1
|
||||
github.com/mattn/go-sqlite3 v1.14.24
|
||||
)
|
||||
|
||||
require github.com/joho/godotenv v1.5.1 // indirect
|
||||
@ -1,6 +0,0 @@
|
||||
github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
|
||||
github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
|
||||
github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
|
||||
github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
|
||||
github.com/mattn/go-sqlite3 v1.14.24 h1:tpSp2G2KyMnnQu99ngJ47EIkWVmliIizyZBfPrBWDRM=
|
||||
github.com/mattn/go-sqlite3 v1.14.24/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
|
||||
@ -1,157 +0,0 @@
|
||||
package handlers
|
||||
|
||||
import (
|
||||
"PersonApp/httpClient"
|
||||
"PersonApp/models"
|
||||
"PersonApp/repository"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"github.com/gorilla/mux"
|
||||
"net/http"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
func InitRoutes(r *mux.Router, rep repository.PersonRepository, cln httpClient.Client) {
|
||||
r.HandleFunc("/", GetPersons(rep, cln)).Methods("GET")
|
||||
r.HandleFunc("/{id:[0-9]+}", GetPersonById(rep, cln)).Methods("GET")
|
||||
r.HandleFunc("/", CreatePerson(rep)).Methods("POST")
|
||||
r.HandleFunc("/{id:[0-9]+}", UpdatePerson(rep)).Methods("PUT")
|
||||
r.HandleFunc("/{id:[0-9]+}", DeletePerson(rep)).Methods("DELETE")
|
||||
}
|
||||
|
||||
func GetPersons(rep repository.PersonRepository, cln httpClient.Client) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
fmt.Println("GET PERSONS")
|
||||
|
||||
persons, err := rep.GetAllPersons()
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
for i := 0; i < len(persons); i++ {
|
||||
tasks, _ := cln.GetPersonTasks(persons[i].Id)
|
||||
persons[i].Tasks = tasks
|
||||
}
|
||||
|
||||
err = json.NewEncoder(w).Encode(persons)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func GetPersonById(rep repository.PersonRepository, cln httpClient.Client) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
id, err := strconv.Atoi(mux.Vars(r)["id"])
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
person, err := rep.GetPersonById(id)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
tasks, err := cln.GetPersonTasks(id)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
} else {
|
||||
person.Tasks = tasks
|
||||
}
|
||||
|
||||
err = json.NewEncoder(w).Encode(person)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func CreatePerson(rep repository.PersonRepository) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
|
||||
var person *models.Person
|
||||
|
||||
err := json.NewDecoder(r.Body).Decode(&person)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
person, err = rep.CreatePerson(*person)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
w.WriteHeader(http.StatusCreated)
|
||||
err = json.NewEncoder(w).Encode(person)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func UpdatePerson(rep repository.PersonRepository) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
|
||||
id, err := strconv.Atoi(mux.Vars(r)["id"])
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
var person *models.Person
|
||||
err = json.NewDecoder(r.Body).Decode(&person)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
person, err = rep.UpdatePerson(models.Person{
|
||||
Id: id,
|
||||
Name: person.Name,
|
||||
Tasks: nil,
|
||||
})
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
w.WriteHeader(http.StatusAccepted)
|
||||
err = json.NewEncoder(w).Encode(person)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func DeletePerson(rep repository.PersonRepository) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
|
||||
id, err := strconv.Atoi(mux.Vars(r)["id"])
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
err = rep.DeletePerson(id)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
w.WriteHeader(http.StatusOK)
|
||||
}
|
||||
}
|
||||
@ -1,72 +0,0 @@
|
||||
package httpClient
|
||||
|
||||
import (
|
||||
"PersonApp/models"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Client interface {
|
||||
GetPersonTasks(id int) ([]models.Task, error)
|
||||
TestConnection() (bool, error)
|
||||
}
|
||||
|
||||
type client struct {
|
||||
BaseUrl string
|
||||
Timeout time.Duration
|
||||
}
|
||||
|
||||
func (c *client) TestConnection() (bool, error) {
|
||||
client := &http.Client{Timeout: c.Timeout}
|
||||
url := fmt.Sprintf("%s/", c.BaseUrl)
|
||||
resp, err := client.Get(url)
|
||||
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
|
||||
defer func(Body io.ReadCloser) {
|
||||
err := Body.Close()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
}(resp.Body)
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return false, fmt.Errorf("bad status code: %d", resp.StatusCode)
|
||||
}
|
||||
return true, nil
|
||||
}
|
||||
|
||||
func (c *client) GetPersonTasks(id int) ([]models.Task, error) {
|
||||
client := &http.Client{Timeout: c.Timeout * time.Second}
|
||||
url := fmt.Sprintf("%s/f/%d", c.BaseUrl, id)
|
||||
|
||||
resp, err := client.Get(url)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer func(Body io.ReadCloser) {
|
||||
err := Body.Close()
|
||||
if err != nil {
|
||||
|
||||
}
|
||||
}(resp.Body)
|
||||
|
||||
body, _ := io.ReadAll(resp.Body)
|
||||
|
||||
var tasks []models.Task
|
||||
if err := json.Unmarshal(body, &tasks); err != nil {
|
||||
fmt.Printf("Unmarshal error: %s", err)
|
||||
return []models.Task{}, err
|
||||
}
|
||||
|
||||
return tasks, nil
|
||||
}
|
||||
|
||||
func NewClient(baseUrl string, timeout time.Duration) Client {
|
||||
return &client{BaseUrl: baseUrl, Timeout: timeout}
|
||||
}
|
||||
@ -1,34 +0,0 @@
|
||||
GET http://localhost/person-app/
|
||||
Accept: application/json
|
||||
|
||||
###
|
||||
|
||||
GET http://localhost/person-app/1
|
||||
Accept: application/json
|
||||
|
||||
###
|
||||
|
||||
POST http://localhost/person-app/
|
||||
Accept: application/json
|
||||
Content-Type: application/json
|
||||
|
||||
{
|
||||
"name": "TEST3"
|
||||
}
|
||||
|
||||
###
|
||||
|
||||
PUT http://localhost/person-app/3
|
||||
Accept: application/json
|
||||
Content-Type: application/json
|
||||
|
||||
{
|
||||
"name": "TEST11"
|
||||
}
|
||||
|
||||
###
|
||||
|
||||
DELETE http://localhost/person-app/3
|
||||
Accept: application/json
|
||||
|
||||
###
|
||||
@ -1,47 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"PersonApp/handlers"
|
||||
"PersonApp/httpClient"
|
||||
"PersonApp/repository"
|
||||
"PersonApp/storage"
|
||||
"github.com/gorilla/mux"
|
||||
"github.com/joho/godotenv"
|
||||
"net/http"
|
||||
"os"
|
||||
"strconv"
|
||||
"time"
|
||||
)
|
||||
|
||||
func main() {
|
||||
err := godotenv.Load(".env")
|
||||
if err != nil {
|
||||
panic("Error loading .env file")
|
||||
}
|
||||
|
||||
url := os.Getenv("TASK_APP_URL")
|
||||
port := os.Getenv("PORT")
|
||||
databasePath := os.Getenv("DATABASE")
|
||||
timeout, err := strconv.Atoi(os.Getenv("TIMEOUT"))
|
||||
|
||||
if err != nil {
|
||||
panic("Error converting timeout to int")
|
||||
}
|
||||
|
||||
database, err := storage.Init(databasePath)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
cln := httpClient.NewClient(url, time.Duration(timeout))
|
||||
rep := repository.NewPersonRepository(database)
|
||||
router := mux.NewRouter()
|
||||
handlers.InitRoutes(router, rep, cln)
|
||||
|
||||
err = http.ListenAndServe(":"+port, router)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
storage.Close(database)
|
||||
}
|
||||
@ -1,24 +0,0 @@
|
||||
package models
|
||||
|
||||
type Person struct {
|
||||
Id int `json:"id"`
|
||||
Name string `json:"name"`
|
||||
Tasks []Task `json:"tasks"`
|
||||
}
|
||||
|
||||
type PersonCreate struct {
|
||||
Name string `json:"name"`
|
||||
}
|
||||
|
||||
type Task struct {
|
||||
Id int `json:"id"`
|
||||
PersonId int `json:"person_id"`
|
||||
Name string `json:"name"`
|
||||
Date string `json:"date"`
|
||||
}
|
||||
|
||||
type TaskCreate struct {
|
||||
PersonId int `json:"person_id"`
|
||||
Name string `json:"name"`
|
||||
Date string `json:"date"`
|
||||
}
|
||||
@ -1,99 +0,0 @@
|
||||
package repository
|
||||
|
||||
import (
|
||||
"PersonApp/models"
|
||||
"database/sql"
|
||||
)
|
||||
|
||||
type PersonRepository interface {
|
||||
GetAllPersons() ([]models.Person, error)
|
||||
GetPersonById(id int) (*models.Person, error)
|
||||
CreatePerson(person models.Person) (*models.Person, error)
|
||||
UpdatePerson(person models.Person) (*models.Person, error)
|
||||
DeletePerson(id int) error
|
||||
}
|
||||
|
||||
type personRepository struct {
|
||||
DB *sql.DB
|
||||
}
|
||||
|
||||
func NewPersonRepository(db *sql.DB) PersonRepository {
|
||||
return &personRepository{DB: db}
|
||||
}
|
||||
|
||||
func (pr *personRepository) GetAllPersons() ([]models.Person, error) {
|
||||
rows, err := pr.DB.Query("select * from Persons")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
defer func(rows *sql.Rows) {
|
||||
err := rows.Close()
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}(rows)
|
||||
|
||||
var persons []models.Person
|
||||
|
||||
for rows.Next() {
|
||||
p := models.Person{}
|
||||
err := rows.Scan(&p.Id, &p.Name)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
persons = append(persons, p)
|
||||
}
|
||||
|
||||
return persons, err
|
||||
}
|
||||
|
||||
func (pr *personRepository) GetPersonById(id int) (*models.Person, error) {
|
||||
row := pr.DB.QueryRow("select * from Persons where id=?", id)
|
||||
|
||||
person := models.Person{}
|
||||
err := row.Scan(&person.Id, &person.Name)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return &person, err
|
||||
}
|
||||
|
||||
func (pr *personRepository) CreatePerson(p models.Person) (*models.Person, error) {
|
||||
res, err := pr.DB.Exec("INSERT INTO Persons (name) values (?)", p.Name)
|
||||
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if res == nil {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
return &p, err
|
||||
}
|
||||
|
||||
func (pr *personRepository) UpdatePerson(p models.Person) (*models.Person, error) {
|
||||
res, err := pr.DB.Exec("UPDATE Persons SET name = ? WHERE id = ?", p.Name, p.Id)
|
||||
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if res == nil {
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
return &p, err
|
||||
}
|
||||
|
||||
func (pr *personRepository) DeletePerson(id int) error {
|
||||
_, err := pr.DB.Exec("DELETE FROM Persons WHERE id = ?", id)
|
||||
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@ -1,36 +0,0 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
_ "github.com/mattn/go-sqlite3"
|
||||
)
|
||||
|
||||
func Init(databasePath string) (*sql.DB, error) {
|
||||
db, err := sql.Open("sqlite3", databasePath)
|
||||
|
||||
if err != nil || db == nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if err := createTableIfNotExists(db); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return db, nil
|
||||
}
|
||||
|
||||
func Close(db *sql.DB) {
|
||||
err := db.Close()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
func createTableIfNotExists(db *sql.DB) error {
|
||||
if result, err := db.Exec(
|
||||
"CREATE TABLE IF NOT EXISTS `Persons`(Id integer primary key autoincrement, Name text not null);",
|
||||
); err != nil || result == nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@ -1,4 +0,0 @@
|
||||
PORT=8000
|
||||
PERSON_APP_URL=http://person-app:8080
|
||||
TIMEOUT=15
|
||||
DATABASE=./database.db
|
||||
@ -1,14 +0,0 @@
|
||||
FROM golang:1.23
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
COPY go.mod go.sum ./
|
||||
RUN go mod download
|
||||
|
||||
COPY . .
|
||||
|
||||
RUN go build -o /bin/TaskApp
|
||||
|
||||
EXPOSE 8000
|
||||
|
||||
CMD ["/bin/TaskApp"]
|
||||
Binary file not shown.
@ -1,10 +0,0 @@
|
||||
module TaskApp
|
||||
|
||||
go 1.23.1
|
||||
|
||||
require (
|
||||
github.com/gorilla/mux v1.8.1
|
||||
github.com/mattn/go-sqlite3 v1.14.24
|
||||
)
|
||||
|
||||
require github.com/joho/godotenv v1.5.1
|
||||
@ -1,6 +0,0 @@
|
||||
github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
|
||||
github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
|
||||
github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
|
||||
github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
|
||||
github.com/mattn/go-sqlite3 v1.14.24 h1:tpSp2G2KyMnnQu99ngJ47EIkWVmliIizyZBfPrBWDRM=
|
||||
github.com/mattn/go-sqlite3 v1.14.24/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
|
||||
@ -1,177 +0,0 @@
|
||||
package handlers
|
||||
|
||||
import (
|
||||
"TaskApp/httpClient"
|
||||
"TaskApp/models"
|
||||
"TaskApp/repository"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"github.com/gorilla/mux"
|
||||
"net/http"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
func InitRoutes(r *mux.Router, rep repository.TaskRepository, cln httpClient.Client) {
|
||||
r.HandleFunc("/", GetTasks(rep)).Methods("GET")
|
||||
r.HandleFunc("/{id:[0-9]+}", GetTaskById(rep)).Methods("GET")
|
||||
r.HandleFunc("/", CreateTask(rep, cln)).Methods("POST")
|
||||
r.HandleFunc("/{id:[0-9]+}", UpdateTask(rep)).Methods("PUT")
|
||||
r.HandleFunc("/{id:[0-9]+}", DeleteTask(rep)).Methods("DELETE")
|
||||
r.HandleFunc("/f/{id:[0-9]+}", GetPersonTasks(rep)).Methods("GET")
|
||||
}
|
||||
|
||||
func GetTasks(rep repository.TaskRepository) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
tasks, err := rep.GetAllTasks()
|
||||
if err != nil {
|
||||
w.WriteHeader(http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
err = json.NewEncoder(w).Encode(tasks)
|
||||
if err != nil {
|
||||
w.WriteHeader(http.StatusInternalServerError)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func GetTaskById(rep repository.TaskRepository) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
id, err := strconv.Atoi(mux.Vars(r)["id"])
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
person, err := rep.GetTaskById(id)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
err = json.NewEncoder(w).Encode(person)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func GetPersonTasks(rep repository.TaskRepository) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
id, err := strconv.Atoi(mux.Vars(r)["id"])
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
tasks, err := rep.GetUserTasks(id)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
err = json.NewEncoder(w).Encode(tasks)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func CreateTask(rep repository.TaskRepository, cln httpClient.Client) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
|
||||
var task *models.TaskCreate
|
||||
|
||||
err := json.NewDecoder(r.Body).Decode(&task)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
if &task.Name == nil || &task.PersonId == nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
person, err := cln.GetPerson(task.PersonId)
|
||||
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
http.Error(w, "Connection to PersonApp is confused.", http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
if person == nil {
|
||||
http.Error(w, fmt.Sprintf("Person with id=%d is't founded.", person.Id), http.StatusBadGateway)
|
||||
return
|
||||
}
|
||||
|
||||
newTask, err := rep.CreateTask(*task)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
w.WriteHeader(http.StatusCreated)
|
||||
err = json.NewEncoder(w).Encode(newTask)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func UpdateTask(rep repository.TaskRepository) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
|
||||
id, err := strconv.Atoi(mux.Vars(r)["id"])
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
var task *models.TaskCreate
|
||||
|
||||
err = json.NewDecoder(r.Body).Decode(&task)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
|
||||
newTask, err := rep.UpdateTask(models.Task{Id: id, Name: task.Name, Date: task.Date})
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
err = json.NewEncoder(w).Encode(newTask)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func DeleteTask(rep repository.TaskRepository) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
|
||||
id, err := strconv.Atoi(mux.Vars(r)["id"])
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
err = rep.DeleteTask(id)
|
||||
if err != nil {
|
||||
http.Error(w, err.Error(), http.StatusInternalServerError)
|
||||
return
|
||||
}
|
||||
w.WriteHeader(http.StatusOK)
|
||||
}
|
||||
}
|
||||
@ -1,73 +0,0 @@
|
||||
package httpClient
|
||||
|
||||
import (
|
||||
"TaskApp/models"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"log"
|
||||
"net/http"
|
||||
"time"
|
||||
)
|
||||
|
||||
type Client interface {
|
||||
GetPerson(id int) (*models.Person, error)
|
||||
TestConnection() (bool, error)
|
||||
}
|
||||
|
||||
type client struct {
|
||||
BaseUrl string
|
||||
Timeout time.Duration
|
||||
}
|
||||
|
||||
func (c *client) TestConnection() (bool, error) {
|
||||
client := &http.Client{Timeout: c.Timeout}
|
||||
url := fmt.Sprintf("%s/", c.BaseUrl)
|
||||
resp, err := client.Get(url)
|
||||
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
|
||||
defer func(Body io.ReadCloser) {
|
||||
err := Body.Close()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
}(resp.Body)
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
return false, fmt.Errorf("bad status code: %d", resp.StatusCode)
|
||||
}
|
||||
return true, nil
|
||||
}
|
||||
|
||||
func (c *client) GetPerson(id int) (*models.Person, error) {
|
||||
client := &http.Client{Timeout: c.Timeout * time.Second}
|
||||
url := fmt.Sprintf("%s/%d", c.BaseUrl, id)
|
||||
|
||||
resp, err := client.Get(url)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer func(Body io.ReadCloser) {
|
||||
err := Body.Close()
|
||||
if err != nil {
|
||||
|
||||
}
|
||||
}(resp.Body)
|
||||
|
||||
body, _ := io.ReadAll(resp.Body)
|
||||
|
||||
var person models.Person
|
||||
if err := json.Unmarshal(body, &person); err != nil {
|
||||
log.Printf("Unmarshal error: %s", err)
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return &person, nil
|
||||
}
|
||||
|
||||
func NewClient(baseUrl string, timeout time.Duration) Client {
|
||||
return &client{BaseUrl: baseUrl, Timeout: timeout}
|
||||
}
|
||||
@ -1,37 +0,0 @@
|
||||
GET http://localhost/task-app/
|
||||
Accept: application/json
|
||||
|
||||
###
|
||||
|
||||
GET http://localhost/task-app/4
|
||||
Accept: application/json
|
||||
|
||||
###
|
||||
|
||||
POST http://localhost/task-app/
|
||||
Accept: application/json
|
||||
Content-Type: application/json
|
||||
|
||||
{
|
||||
"name": "TEST2",
|
||||
"person_id": 1,
|
||||
"date": "19.02.2202"
|
||||
}
|
||||
|
||||
###
|
||||
|
||||
PUT http://localhost/task-app/4
|
||||
Accept: application/json
|
||||
Content-Type: application/json
|
||||
|
||||
{
|
||||
"name": "TEST5",
|
||||
"date": "19.02.2202"
|
||||
}
|
||||
|
||||
###
|
||||
|
||||
DELETE http://localhost/task-app/4
|
||||
Accept: application/json
|
||||
|
||||
###
|
||||
@ -1,47 +0,0 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"TaskApp/handlers"
|
||||
"TaskApp/httpClient"
|
||||
"TaskApp/repository"
|
||||
"TaskApp/storage"
|
||||
"github.com/gorilla/mux"
|
||||
"github.com/joho/godotenv"
|
||||
"net/http"
|
||||
"os"
|
||||
"strconv"
|
||||
"time"
|
||||
)
|
||||
|
||||
func main() {
|
||||
err := godotenv.Load(".env")
|
||||
if err != nil {
|
||||
panic("Error loading .env file")
|
||||
}
|
||||
|
||||
url := os.Getenv("PERSON_APP_URL")
|
||||
port := os.Getenv("PORT")
|
||||
databasePath := os.Getenv("DATABASE")
|
||||
timeout, err := strconv.Atoi(os.Getenv("TIMEOUT"))
|
||||
|
||||
if err != nil {
|
||||
panic("Error converting timeout to int")
|
||||
}
|
||||
|
||||
database, err := storage.Init(databasePath)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
cln := httpClient.NewClient(url, time.Duration(timeout))
|
||||
rep := repository.NewTaskRepository(database)
|
||||
router := mux.NewRouter()
|
||||
handlers.InitRoutes(router, rep, cln)
|
||||
|
||||
err = http.ListenAndServe(":"+port, router)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
storage.Close(database)
|
||||
}
|
||||
@ -1,24 +0,0 @@
|
||||
package models
|
||||
|
||||
type Person struct {
|
||||
Id int `json:"id"`
|
||||
Name string `json:"name"`
|
||||
Tasks []Task `json:"tasks"`
|
||||
}
|
||||
|
||||
type PersonCreate struct {
|
||||
Name string `json:"name"`
|
||||
}
|
||||
|
||||
type Task struct {
|
||||
Id int `json:"id"`
|
||||
PersonId int `json:"person_id"`
|
||||
Name string `json:"name"`
|
||||
Date string `json:"date"`
|
||||
}
|
||||
|
||||
type TaskCreate struct {
|
||||
PersonId int `json:"person_id"`
|
||||
Name string `json:"name"`
|
||||
Date string `json:"date"`
|
||||
}
|
||||
@ -1,121 +0,0 @@
|
||||
package repository
|
||||
|
||||
import (
|
||||
"TaskApp/models"
|
||||
"database/sql"
|
||||
)
|
||||
|
||||
type TaskRepository interface {
|
||||
GetAllTasks() ([]models.Task, error)
|
||||
GetTaskById(id int) (*models.Task, error)
|
||||
GetUserTasks(id int) ([]models.Task, error)
|
||||
CreateTask(task models.TaskCreate) (*models.Task, error)
|
||||
UpdateTask(task models.Task) (*models.Task, error)
|
||||
DeleteTask(id int) error
|
||||
}
|
||||
|
||||
type taskRepository struct {
|
||||
DB *sql.DB
|
||||
}
|
||||
|
||||
func (t taskRepository) GetUserTasks(id int) ([]models.Task, error) {
|
||||
rows, err := t.DB.Query("select * from Tasks where PersonId = ?", id)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
defer func(rows *sql.Rows) {
|
||||
err := rows.Close()
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}(rows)
|
||||
|
||||
var tasks []models.Task
|
||||
|
||||
for rows.Next() {
|
||||
p := models.Task{}
|
||||
err := rows.Scan(&p.Id, &p.Name, &p.PersonId, &p.Date)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
tasks = append(tasks, p)
|
||||
}
|
||||
|
||||
return tasks, err
|
||||
}
|
||||
|
||||
func (t taskRepository) GetAllTasks() ([]models.Task, error) {
|
||||
rows, err := t.DB.Query("select * from Tasks")
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
defer func(rows *sql.Rows) {
|
||||
err := rows.Close()
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
}(rows)
|
||||
|
||||
var tasks []models.Task
|
||||
|
||||
for rows.Next() {
|
||||
p := models.Task{}
|
||||
err := rows.Scan(&p.Id, &p.Name, &p.PersonId, &p.Date)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
tasks = append(tasks, p)
|
||||
}
|
||||
|
||||
return tasks, err
|
||||
}
|
||||
|
||||
func (t taskRepository) GetTaskById(id int) (*models.Task, error) {
|
||||
row := t.DB.QueryRow("select * from Tasks where id=?", id)
|
||||
|
||||
task := models.Task{}
|
||||
err := row.Scan(&task.Id, &task.Name, &task.PersonId, &task.Date)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return &task, err
|
||||
}
|
||||
|
||||
func (t taskRepository) CreateTask(task models.TaskCreate) (*models.Task, error) {
|
||||
_, err := t.DB.Exec("INSERT INTO Tasks(Name, PersonId, Date) VALUES (?, ?, ?)", task.Name, task.PersonId, task.Date)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return &models.Task{
|
||||
Id: 0,
|
||||
PersonId: task.PersonId,
|
||||
Name: task.Name,
|
||||
Date: task.Date,
|
||||
}, err
|
||||
}
|
||||
|
||||
func (t taskRepository) UpdateTask(task models.Task) (*models.Task, error) {
|
||||
_, err := t.DB.Exec("UPDATE Tasks SET name = ?, date = ? WHERE id = ?", task.Name, task.Date, task.Id)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return &task, err
|
||||
}
|
||||
|
||||
func (t taskRepository) DeleteTask(id int) error {
|
||||
_, err := t.DB.Exec("DELETE FROM Tasks WHERE id = ?", id)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func NewTaskRepository(db *sql.DB) TaskRepository {
|
||||
return &taskRepository{DB: db}
|
||||
}
|
||||
@ -1,36 +0,0 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"database/sql"
|
||||
_ "github.com/mattn/go-sqlite3"
|
||||
)
|
||||
|
||||
func Init(databasePath string) (*sql.DB, error) {
|
||||
db, err := sql.Open("sqlite3", databasePath)
|
||||
|
||||
if err != nil || db == nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if err := createTableIfNotExists(db); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return db, nil
|
||||
}
|
||||
|
||||
func Close(db *sql.DB) {
|
||||
err := db.Close()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
func createTableIfNotExists(db *sql.DB) error {
|
||||
if result, err := db.Exec(
|
||||
"CREATE TABLE IF NOT EXISTS `Tasks`(Id integer primary key autoincrement, Name text not null, PersonId integer not null, Date text not null);",
|
||||
); err != nil || result == nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@ -1,34 +0,0 @@
|
||||
services:
|
||||
person-app:
|
||||
build:
|
||||
context: ./PersonApp
|
||||
dockerfile: Dockerfile
|
||||
networks:
|
||||
- network
|
||||
ports:
|
||||
- "8080:8080"
|
||||
|
||||
task-app:
|
||||
build:
|
||||
context: ./TaskApp
|
||||
dockerfile: Dockerfile
|
||||
networks:
|
||||
- network
|
||||
ports:
|
||||
- "8000:8000"
|
||||
|
||||
nginx:
|
||||
image: nginx
|
||||
ports:
|
||||
- "80:80"
|
||||
volumes:
|
||||
- ./nginx.conf:/etc/nginx/nginx.conf
|
||||
networks:
|
||||
- network
|
||||
depends_on:
|
||||
- person-app
|
||||
- task-app
|
||||
|
||||
networks:
|
||||
network:
|
||||
driver: bridge
|
||||
@ -1,59 +0,0 @@
|
||||
events {
|
||||
worker_connections 1024;
|
||||
}
|
||||
|
||||
http {
|
||||
server {
|
||||
listen 80;
|
||||
server_name localhost;
|
||||
|
||||
location /person-app/ {
|
||||
proxy_pass http://person-app:8080/;
|
||||
proxy_set_header Host $host;
|
||||
proxy_set_header X-Real-IP $remote_addr;
|
||||
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
|
||||
proxy_set_header X-Forwarded-Proto $scheme;
|
||||
add_header 'Access-Control-Allow-Origin' '*';
|
||||
add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS';
|
||||
add_header 'Access-Control-Allow-Headers' 'Origin, Content-Type, Accept, Authorization';
|
||||
|
||||
}
|
||||
|
||||
location /task-app/ {
|
||||
proxy_pass http://task-app:8000/;
|
||||
proxy_set_header Host $host;
|
||||
proxy_set_header X-Real-IP $remote_addr;
|
||||
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
|
||||
proxy_set_header X-Forwarded-Proto $scheme;
|
||||
add_header 'Access-Control-Allow-Origin' '*';
|
||||
add_header 'Access-Control-Allow-Methods' 'GET, POST, OPTIONS';
|
||||
add_header 'Access-Control-Allow-Headers' 'Origin, Content-Type, Accept, Authorization';
|
||||
}
|
||||
|
||||
# Прокси для Swagger (Stream-сервис)
|
||||
#location /stream-service/swagger/ {
|
||||
# proxy_pass http://stream-service:8000/swagger/;
|
||||
# proxy_set_header Host $host;
|
||||
# proxy_set_header X-Real-IP $remote_addr;
|
||||
# proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
|
||||
# proxy_set_header X-Forwarded-Proto $scheme;
|
||||
#}
|
||||
|
||||
# Прокси для Swagger (Message-сервис)
|
||||
#location /message-service/swagger/ {
|
||||
# proxy_pass http://message-service:8080/swagger/;
|
||||
# proxy_set_header Host $host;
|
||||
# proxy_set_header X-Real-IP $remote_addr;
|
||||
# proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
|
||||
# proxy_set_header X-Forwarded-Proto $scheme;
|
||||
#}
|
||||
|
||||
#location /stream-service/doc.json {
|
||||
# proxy_pass http://stream-service:8000/doc.json;
|
||||
#}
|
||||
|
||||
#location /message-service/doc.json {
|
||||
# proxy_pass http://message-service:8080/doc.json;
|
||||
#}
|
||||
}
|
||||
}
|
||||
@ -1,34 +0,0 @@
|
||||
# Лабораторная работа №4: Работа с брокером сообщений (RabbitMQ)
|
||||
|
||||
## Цель
|
||||
|
||||
Изучение проектирования приложений с использованием брокера сообщений RabbitMQ.
|
||||
|
||||
---
|
||||
|
||||
## Задачи
|
||||
|
||||
> 1. **Установить RabbitMQ**
|
||||
Установите RabbitMQ на локальный компьютер (или используйте Docker).
|
||||
>- [Скачивание RabbitMQ](https://www.rabbitmq.com/download.html)
|
||||
>- [Релизы RabbitMQ](https://github.com/rabbitmq/rabbitmq-server/releases/)
|
||||
>- **Пройти уроки RabbitMQ**
|
||||
>- Сделайте скриншоты, показывающие запуск `producer` и `consumer` и передачу сообщений.
|
||||
|
||||
---
|
||||
## Первый урок
|
||||
> 
|
||||
|
||||
---
|
||||
## Второй урок
|
||||
>
|
||||
>
|
||||
|
||||
---
|
||||
## Третий урок
|
||||
> 
|
||||
|
||||
---
|
||||
## Задача
|
||||
>
|
||||
> 
|
||||
@ -1,17 +0,0 @@
|
||||
version: "3.2"
|
||||
services:
|
||||
rabbitmq:
|
||||
image: rabbitmq:3-management-alpine
|
||||
container_name: 'rabbitmq'
|
||||
ports:
|
||||
- "5672:5672"
|
||||
- "15672:15672"
|
||||
volumes:
|
||||
- ~/.docker-conf/rabbitmq/data/:/var/lib/rabbitmq/
|
||||
- ~/.docker-conf/rabbitmq/log/:/var/log/rabbitmq
|
||||
networks:
|
||||
- rabbitmq_go_net
|
||||
|
||||
networks:
|
||||
rabbitmq_go_net:
|
||||
driver: bridge
|
||||
@ -1,47 +0,0 @@
|
||||
from datetime import datetime
|
||||
import random
|
||||
import threading
|
||||
|
||||
import pika
|
||||
import sys
|
||||
|
||||
_alphabet = [chr(i) for i in range(97, 123)]
|
||||
|
||||
|
||||
def run_every_n_seconds(seconds, action, *args):
|
||||
threading.Timer(seconds, run_every_n_seconds, [seconds, action] + list(args)).start()
|
||||
action(*args)
|
||||
|
||||
|
||||
def generate_message():
|
||||
now = datetime.now()
|
||||
current_time = now.strftime("%H:%M:%S")
|
||||
return f"[{current_time}] " + "".join(random.choices(_alphabet, k=random.randint(1, 10)))
|
||||
|
||||
|
||||
def send_message(channel_local):
|
||||
message = generate_message()
|
||||
channel_local.basic_publish(
|
||||
exchange='vk_messages',
|
||||
routing_key='vk_messages',
|
||||
body=message,
|
||||
properties=pika.BasicProperties(
|
||||
delivery_mode=pika.DeliveryMode.Persistent
|
||||
))
|
||||
print(f"[vkAuthor] Sent {message}")
|
||||
|
||||
|
||||
def main(conn: pika.BlockingConnection):
|
||||
channel = conn.channel()
|
||||
channel.exchange_declare(exchange='vk_messages', exchange_type='fanout')
|
||||
run_every_n_seconds(1, send_message, channel)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
|
||||
|
||||
try:
|
||||
main(connection)
|
||||
except KeyboardInterrupt:
|
||||
connection.close()
|
||||
sys.exit(0)
|
||||
@ -1,44 +0,0 @@
|
||||
import sys
|
||||
from datetime import datetime
|
||||
|
||||
import pika
|
||||
|
||||
_QUEUE_NAME = "vk_messages_queue"
|
||||
_EXCHANGE_NAME = "vk_messages"
|
||||
|
||||
|
||||
def main():
|
||||
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
|
||||
channel = connection.channel()
|
||||
|
||||
channel.exchange_declare(
|
||||
exchange=_EXCHANGE_NAME,
|
||||
exchange_type='fanout'
|
||||
)
|
||||
|
||||
channel.queue_declare(queue=_QUEUE_NAME, exclusive=True)
|
||||
channel.queue_bind(exchange=_EXCHANGE_NAME, queue=_QUEUE_NAME)
|
||||
|
||||
def callback(ch, method, properties, body):
|
||||
now = datetime.now()
|
||||
current_time = now.strftime("%H:%M:%S")
|
||||
|
||||
print(f"[vkReader] Received [{str(body)}] in [{current_time}]")
|
||||
ch.basic_ack(delivery_tag=method.delivery_tag)
|
||||
|
||||
channel.basic_consume(
|
||||
queue=_QUEUE_NAME,
|
||||
on_message_callback=callback,
|
||||
auto_ack=False
|
||||
)
|
||||
|
||||
print('[*] Waiting for messages. To exit press CTRL+C')
|
||||
channel.start_consuming()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
try:
|
||||
main()
|
||||
except KeyboardInterrupt:
|
||||
print('Interrupted')
|
||||
sys.exit(0)
|
||||
@ -1,47 +0,0 @@
|
||||
import time
|
||||
import random
|
||||
from datetime import datetime
|
||||
|
||||
import pika
|
||||
import sys
|
||||
|
||||
_QUEUE_NAME = "vk_messages_queue_slow"
|
||||
_EXCHANGE_NAME = "vk_messages"
|
||||
|
||||
|
||||
def main():
|
||||
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost'))
|
||||
channel = connection.channel()
|
||||
|
||||
channel.exchange_declare(
|
||||
exchange=_EXCHANGE_NAME,
|
||||
exchange_type='fanout'
|
||||
)
|
||||
channel.queue_declare(queue=_QUEUE_NAME, exclusive=True)
|
||||
channel.queue_bind(exchange=_EXCHANGE_NAME, queue=_QUEUE_NAME)
|
||||
|
||||
def callback(ch, method, properties, body):
|
||||
now = datetime.now()
|
||||
current_time = now.strftime("%H:%M:%S")
|
||||
|
||||
print(f"[vkSlowReader] Received [{str(body)}] in [{current_time}]")
|
||||
read_time = random.randint(2, 5)
|
||||
time.sleep(read_time)
|
||||
ch.basic_ack(delivery_tag=method.delivery_tag)
|
||||
|
||||
channel.basic_consume(
|
||||
queue=_QUEUE_NAME,
|
||||
on_message_callback=callback,
|
||||
auto_ack=False
|
||||
)
|
||||
|
||||
print('[*] Waiting for messages. To exit press CTRL+C')
|
||||
channel.start_consuming()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
try:
|
||||
main()
|
||||
except KeyboardInterrupt:
|
||||
print('Interrupted')
|
||||
sys.exit(0)
|
||||
@ -1,25 +0,0 @@
|
||||
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')
|
||||
sys.exit(0)
|
||||
@ -1,11 +0,0 @@
|
||||
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()
|
||||
@ -1,19 +0,0 @@
|
||||
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()
|
||||
@ -1,22 +0,0 @@
|
||||
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()
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 35 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 37 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 14 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 24 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 29 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 204 KiB |
@ -1,13 +0,0 @@
|
||||
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()
|
||||
@ -1,24 +0,0 @@
|
||||
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()
|
||||
2
bogdanov_dmitry_lab_2/.gitignore
vendored
2
bogdanov_dmitry_lab_2/.gitignore
vendored
@ -1,2 +0,0 @@
|
||||
data/
|
||||
result/
|
||||
@ -1,41 +0,0 @@
|
||||
# Лабораторная работа №2
|
||||
|
||||
## Богданов Дмитрий ПИбд-42
|
||||
|
||||
### Для выполнения была проделана следующая работа:
|
||||
Были написаны и развернуты 3 сервиса: генератор файлов, 2 приложения для работы с этими файлами по вариантам 2 и 1 соответственно:
|
||||
|
||||
Вариант 2 (для первого приложения):
|
||||
|
||||
```Формирует файл /var/result/data.txt из первых строк всех файлов каталога /var/data.```
|
||||
|
||||
Вариант 1 (для второго приложения):
|
||||
|
||||
```Ищет набольшее число из файла /var/data/data.txt и сохраняет его вторую степень в /var/result/result.txt.```
|
||||
|
||||
Приложения работают совместно, используя общий монтированный том для записи и получения информации:
|
||||
```
|
||||
volumes:
|
||||
- ./data:/var/data
|
||||
```
|
||||
```
|
||||
volumes:
|
||||
- ./data:/var/data
|
||||
- ./result:/var/result
|
||||
```
|
||||
```
|
||||
volumes:
|
||||
- ./result:/var/result
|
||||
```
|
||||
|
||||
|
||||
### Запуск лабораторной:
|
||||
Необходимо перейти в папку с файлом docker-compose.yaml и ввести следующую команду:
|
||||
```
|
||||
docker compose up --build
|
||||
```
|
||||
Сервис генератора сгенерирует папки data и result, где будут сгенерированы входные файлы и файл-результат их обработки соответственно.
|
||||
|
||||
## Видео с результатом запуска:
|
||||
|
||||
Видео-демонстрацию работы можно посмотреть по данной [ссылке](https://drive.google.com/file/d/1CmVZjJuMStqNFFKbsMLjw4ihTiMnR7it/view).
|
||||
@ -1,7 +0,0 @@
|
||||
FROM python:latest
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
COPY app.py /app/
|
||||
|
||||
CMD ["python", "app.py"]
|
||||
@ -1,30 +0,0 @@
|
||||
import os
|
||||
|
||||
# Вариант 2 - Формирует файл /var/result/data.txt из первых строк всех файлов каталога /var/data.
|
||||
def solve(dir_files, dir_result, filename_result):
|
||||
# Получаем список файлов в директории
|
||||
filenames = os.listdir(dir_files)
|
||||
result = ''
|
||||
# Проходим через каждый файл
|
||||
for filename in filenames:
|
||||
filepath = os.path.join(dir_files, filename)
|
||||
file = open(filepath, "r")
|
||||
# Читаем первую строку, добавляем к результату
|
||||
result += f"{file.readline()}"
|
||||
file.close()
|
||||
|
||||
# Если директории для сохранения результата нет - создаём
|
||||
if not os.path.exists(dir_result):
|
||||
os.makedirs(dir_result)
|
||||
# Если директория с результатом не пустая - завершаем работу
|
||||
if os.listdir(dir_result):
|
||||
return
|
||||
# Пишем результат в файл
|
||||
filepath_result = os.path.join(dir_result, filename_result)
|
||||
result_file = open(filepath_result, "w")
|
||||
result_file.write(result)
|
||||
print(f"Результат записан в файл {filepath_result}")
|
||||
result_file.close()
|
||||
|
||||
if __name__ == "__main__":
|
||||
solve('/var/data', '/var/result', 'data.txt')
|
||||
@ -1,7 +0,0 @@
|
||||
FROM python:latest
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
COPY app.py /app/
|
||||
|
||||
CMD ["python", "app.py"]
|
||||
@ -1,21 +0,0 @@
|
||||
import os
|
||||
|
||||
# Вариант 1 - Ищет набольшее число из файла /var/data/data.txt и сохраняет его вторую степень в /var/result/result.txt.
|
||||
def solve(dir_input, dir_result, filename_result):
|
||||
file_input = open(os.path.join(dir_input, 'data.txt'))
|
||||
# Считываем все числа из файла
|
||||
inputs = [int(line) for line in file_input.readlines()]
|
||||
if inputs:
|
||||
# Максимальное число
|
||||
max_num = max(inputs)
|
||||
print(f"Наибольшее число: {max_num}")
|
||||
# Возводим во 2 степень
|
||||
result = max(inputs) ** 2
|
||||
file_result = open(os.path.join(dir_result, filename_result), "w")
|
||||
# Пишем результат в файл
|
||||
file_result.write(str(result))
|
||||
print(f"Получен результат {result}")
|
||||
file_result.close()
|
||||
|
||||
if __name__ == "__main__":
|
||||
solve("/var/result", '/var/result', 'result.txt')
|
||||
@ -1,7 +0,0 @@
|
||||
FROM python:latest
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
COPY generator.py /app/
|
||||
|
||||
CMD ["python", "generate_files.py"]
|
||||
@ -1,30 +0,0 @@
|
||||
import os
|
||||
import random as rnd
|
||||
import string
|
||||
|
||||
# Генератор названий файлов
|
||||
def generate_filename(l):
|
||||
return ''.join(rnd.choices(string.ascii_lowercase + string.digits, k=l)) + '.txt'
|
||||
|
||||
def generate_files(dir, num_files, num_lines):
|
||||
# Если директории для сохранения файлов нет - создаём
|
||||
if not os.path.exists(dir):
|
||||
os.makedirs(dir)
|
||||
|
||||
# Если директория для сохранения файлов не пустая - завершаем работу
|
||||
if os.listdir(dir):
|
||||
return
|
||||
|
||||
# Создание файлов
|
||||
for i in range(num_files):
|
||||
filename = generate_filename(20)
|
||||
filepath = os.path.join(dir, filename)
|
||||
|
||||
file = open(filepath, "w")
|
||||
# Запись строк в файл
|
||||
for j in range(num_lines):
|
||||
file.write(f"{rnd.randint(-1000, 1000)}\n")
|
||||
file.close()
|
||||
|
||||
if __name__ == "__main__":
|
||||
generate_files('/var/data', 50, 50)
|
||||
@ -1,27 +0,0 @@
|
||||
services:
|
||||
# Генератор файлов
|
||||
generator:
|
||||
build:
|
||||
context: ./app-generator # Путь к контексту (докер файл + скрипт)
|
||||
volumes:
|
||||
- ./data:/var/data # Папка контейнера : папка локальная
|
||||
entrypoint: python generator.py # Точка входа
|
||||
|
||||
# Первое приложение
|
||||
app1:
|
||||
build:
|
||||
context: ./app-1 # Путь к контексту
|
||||
volumes:
|
||||
- ./data:/var/data # Монтирование папок
|
||||
- ./result:/var/result
|
||||
depends_on:
|
||||
- generator # Указываем, что запускается только после успешной работы сервиса generator
|
||||
|
||||
# Второе приложение, настройка аналогична сервисам выше
|
||||
app2:
|
||||
build:
|
||||
context: ./app-2
|
||||
volumes:
|
||||
- ./result:/var/result
|
||||
depends_on:
|
||||
- app1
|
||||
2
bogdanov_dmitry_lab_3/.gitignore
vendored
2
bogdanov_dmitry_lab_3/.gitignore
vendored
@ -1,2 +0,0 @@
|
||||
/.idea
|
||||
/.venv
|
||||
@ -1,22 +0,0 @@
|
||||
# Лабораторная работа №3
|
||||
|
||||
## Богданов Дмитрий ПИбд-42
|
||||
|
||||
### Для выполнения были выбраны следующие сущности:
|
||||
|
||||
* Message - содержит uuid (генерируется), text, datetime_sent, user_id
|
||||
* User - содержит uuid (генерируется), name, surname
|
||||
|
||||
Одному пользователю может быть присвоено несколько сообщений.
|
||||
|
||||
Соответственно были развернуты 2 сервиса для управления этими сущностями.
|
||||
|
||||
### Запуск лабораторной:
|
||||
Необходимо перейти в папку с файлом compose.yaml и ввести следующую команду:
|
||||
```
|
||||
docker-compose up --build -d
|
||||
```
|
||||
|
||||
## Видео с результатом запуска и тестами...
|
||||
|
||||
...можно посмотреть по данной [ссылке](https://drive.google.com/file/d/1cJz0z4KduSz1oltmAuieUW7GxxVLNPNo/view).
|
||||
@ -1,27 +0,0 @@
|
||||
services:
|
||||
|
||||
user_service:
|
||||
container_name: userService
|
||||
build:
|
||||
context: .
|
||||
dockerfile: ./userService/Dockerfile
|
||||
expose:
|
||||
- 20001
|
||||
|
||||
message_service:
|
||||
container_name: messageService
|
||||
build:
|
||||
context: .
|
||||
dockerfile: ./messageService/Dockerfile
|
||||
expose:
|
||||
- 20002
|
||||
|
||||
nginx:
|
||||
image: nginx:latest
|
||||
ports:
|
||||
- "80:80"
|
||||
volumes:
|
||||
- ./nginx.conf:/etc/nginx/nginx.conf
|
||||
depends_on:
|
||||
- user_service
|
||||
- message_service
|
||||
@ -1,11 +0,0 @@
|
||||
FROM python:latest
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
COPY requirements.txt .
|
||||
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
|
||||
COPY messageService/messageService.py .
|
||||
|
||||
CMD ["python", "messageService.py"]
|
||||
@ -1,138 +0,0 @@
|
||||
from flask import Flask, request, jsonify
|
||||
from uuid import uuid4
|
||||
import uuid
|
||||
import datetime
|
||||
import requests
|
||||
|
||||
class Message:
|
||||
def __init__(self, text: str, datetime_sent: datetime, uuid_: uuid, user_id: uuid):
|
||||
if uuid_ is None:
|
||||
self.uuid_ = uuid4()
|
||||
else:
|
||||
self.uuid_ = uuid.UUID(uuid_)
|
||||
self.text = text
|
||||
self.datetime_sent = datetime_sent
|
||||
self.user_id = uuid.UUID(user_id)
|
||||
|
||||
def to_dict(self):
|
||||
return {
|
||||
'text': self.text,
|
||||
'datetime_sent': self.datetime_sent,
|
||||
'user_id': self.user_id,
|
||||
'uuid': self.uuid_
|
||||
}
|
||||
|
||||
def to_dict_for_users(self):
|
||||
return {
|
||||
'title': self.text,
|
||||
'datetime_sent': self.datetime_sent,
|
||||
'uuid': self.uuid_
|
||||
}
|
||||
|
||||
def to_dict_with_info(self, user: dict):
|
||||
return {
|
||||
'title': self.text,
|
||||
'datetime_sent': self.datetime_sent,
|
||||
'user_id': self.user_id,
|
||||
'user_info': user,
|
||||
'uuid': self.uuid_
|
||||
}
|
||||
|
||||
messages = [
|
||||
Message(text='Hi!', datetime_sent=datetime.datetime.now(), uuid_='4add0525-1857-477d-ad35-56790d400b72', user_id='94b171ea-39f6-4a67-9c67-061743f67cfd'),
|
||||
Message(text='Hello this is a message', datetime_sent=datetime.datetime.now(), uuid_='dd69758d-89e8-49b5-86bf-54ae2adb64e8', user_id='724a3192-70dd-4909-9b0f-c9060a4ab1bd'),
|
||||
Message(text='Test', datetime_sent=datetime.datetime.now(), uuid_='92389e8d-4365-457e-b37e-78abbc07f194', user_id='94b171ea-39f6-4a67-9c67-061743f67cfd'),
|
||||
Message(text='Anyone here?', datetime_sent=datetime.datetime.now(), uuid_='f3a1c526-aca2-47e2-afd3-a1c2eac92458', user_id='724a3192-70dd-4909-9b0f-c9060a4ab1bd'),
|
||||
Message(text='Mambo', datetime_sent=datetime.datetime.now(), uuid_='00abbdb5-e480-4842-bc32-f916894757eb', user_id='46672ea5-3d7b-4137-a0ac-efd898ca4db6')
|
||||
]
|
||||
|
||||
def list_jsonify():
|
||||
return jsonify([message.to_dict() for message in messages])
|
||||
|
||||
|
||||
app = Flask(__name__)
|
||||
users_url = 'http://userService:20001/'
|
||||
|
||||
@app.route('/', methods=['GET'])
|
||||
def get_all():
|
||||
return list_jsonify(), 200
|
||||
|
||||
@app.route('/info', methods=['GET'])
|
||||
def get_all_full():
|
||||
users: list[dict] = requests.get(users_url).json()
|
||||
response = []
|
||||
for message in messages:
|
||||
for user in users:
|
||||
if message.user_id == uuid.UUID(user.get('uuid')):
|
||||
response.append(message.to_dict_with_info(user))
|
||||
|
||||
return response, 200
|
||||
|
||||
@app.route('/by-user/<uuid:user_uuid>', methods=['GET'])
|
||||
def get_by_user_id(user_uuid):
|
||||
return [message.to_dict_for_users() for message in messages if message.user_id == user_uuid], 200
|
||||
|
||||
@app.route('/info/<uuid:uuid_>', methods=['GET'])
|
||||
def get_one_full(uuid_):
|
||||
for message in messages:
|
||||
if message.uuid_ == uuid_:
|
||||
response = requests.get(users_url + str(message.user_id))
|
||||
return message.to_dict_with_info(response.json()), 200
|
||||
|
||||
return f'Сообщение с uuid {uuid_} не найдено', 404
|
||||
|
||||
@app.route('/', methods=['POST'])
|
||||
def create():
|
||||
data = request.json
|
||||
text = data.get('text', None)
|
||||
datetime_sent = datetime.datetime.now()
|
||||
user_id = data.get('user_id', None)
|
||||
checking = requests.get(users_url + f'/check/{user_id}')
|
||||
print(checking)
|
||||
if checking.status_code == 200:
|
||||
new_message = Message(text, datetime_sent, None, user_id)
|
||||
messages.append(new_message)
|
||||
return get_one(new_message.uuid_)
|
||||
if checking.status_code == 404:
|
||||
return f'Пользователь с uuid {user_id} не существует', 404
|
||||
|
||||
return 'Неизвестная ошибка', 500
|
||||
|
||||
@app.route('/<uuid:uuid_>', methods=['PUT'])
|
||||
def update_by_id(uuid_):
|
||||
data = request.json
|
||||
new_text = data.get('text', None)
|
||||
|
||||
for message in messages:
|
||||
print(message.uuid_)
|
||||
|
||||
if message.uuid_ == uuid_:
|
||||
if new_text is not None:
|
||||
message.text = new_text
|
||||
return get_one(message.uuid_)
|
||||
|
||||
return f'Сообщение с uuid {uuid_} не найдено', 404
|
||||
|
||||
|
||||
@app.route('/<uuid:uuid_>', methods=['DELETE'])
|
||||
def delete(uuid_):
|
||||
for message in messages:
|
||||
if message.uuid_ == uuid_:
|
||||
messages.remove(message)
|
||||
return 'Сообщение успешно удалено', 200
|
||||
|
||||
return f'Сообщение с uuid {uuid_} не найдено', 404
|
||||
|
||||
|
||||
|
||||
@app.route('/<uuid:uuid_>', methods=['GET'])
|
||||
def get_one(uuid_):
|
||||
for message in messages:
|
||||
if message.uuid_ == uuid_:
|
||||
return message.to_dict(), 200
|
||||
|
||||
return f'Сообщение с uuid {uuid_} не найдено', 404
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
app.run(host='0.0.0.0', port=20002, debug=True)
|
||||
@ -1,25 +0,0 @@
|
||||
events { worker_connections 1024; }
|
||||
|
||||
http {
|
||||
server {
|
||||
listen 80;
|
||||
listen [::]:80;
|
||||
server_name localhost;
|
||||
|
||||
location /userService/ {
|
||||
proxy_pass http://userService:20001/;
|
||||
proxy_set_header Host $host;
|
||||
proxy_set_header X-Real-IP $remote_addr;
|
||||
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
|
||||
proxy_set_header X-Forwarded-Proto $scheme;
|
||||
}
|
||||
|
||||
location /messageService/ {
|
||||
proxy_pass http://messageService:20002/;
|
||||
proxy_set_header Host $host;
|
||||
proxy_set_header X-Real-IP $remote_addr;
|
||||
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
|
||||
proxy_set_header X-Forwarded-Proto $scheme;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,2 +0,0 @@
|
||||
Flask==3.0.3
|
||||
requests==2.32.3
|
||||
@ -1,11 +0,0 @@
|
||||
FROM python:latest
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
COPY requirements.txt .
|
||||
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
|
||||
COPY userService/userService.py .
|
||||
|
||||
CMD ["python", "userService.py"]
|
||||
@ -1,115 +0,0 @@
|
||||
from flask import Flask, jsonify, request
|
||||
from uuid import uuid4
|
||||
import uuid
|
||||
import requests
|
||||
|
||||
|
||||
class User:
|
||||
def __init__(self, name, surname, uuid_: uuid):
|
||||
if uuid_ is None:
|
||||
self.uuid_: uuid = uuid4()
|
||||
else:
|
||||
self.uuid_: uuid = uuid.UUID(uuid_)
|
||||
self.name: str = name
|
||||
self.surname: str = surname
|
||||
|
||||
def to_dict(self):
|
||||
return {
|
||||
"uuid": self.uuid_,
|
||||
"name": self.name,
|
||||
"surname": self.surname
|
||||
}
|
||||
|
||||
def to_dict_with_messages(self, messages: list):
|
||||
return {
|
||||
"uuid": self.uuid_,
|
||||
"name": self.name,
|
||||
"surname": self.surname,
|
||||
"messages": messages
|
||||
}
|
||||
|
||||
|
||||
app = Flask(__name__)
|
||||
|
||||
users: list[User] = [
|
||||
User(name='Dr.', surname='Kino', uuid_='94b171ea-39f6-4a67-9c67-061743f67cfd'),
|
||||
User(name='Caspian', surname='Holstrom', uuid_='724a3192-70dd-4909-9b0f-c9060a4ab1bd'),
|
||||
User(name='Admin', surname='Admin', uuid_='46672ea5-3d7b-4137-a0ac-efd898ca4db6')
|
||||
]
|
||||
|
||||
messages_url = 'http://messageService:20002/'
|
||||
|
||||
|
||||
def list_jsonify():
|
||||
return jsonify([user.to_dict() for user in users])
|
||||
|
||||
@app.route('/', methods=['GET'])
|
||||
def get_all():
|
||||
return list_jsonify(), 200
|
||||
|
||||
@app.route('/<uuid:uuid_>', methods=['GET'])
|
||||
def get_one(uuid_):
|
||||
for user in users:
|
||||
if user.uuid_ == uuid_:
|
||||
return user.to_dict(), 200
|
||||
|
||||
return f'Пользователь с uuid {uuid_} не найден', 404
|
||||
|
||||
@app.route('/info/<uuid:uuid_>', methods=['GET'])
|
||||
def get_one_with_messages(uuid_):
|
||||
for user in users:
|
||||
if user.uuid_ == uuid_:
|
||||
response = requests.get(messages_url + f'by-user/{uuid_}')
|
||||
print(response.json())
|
||||
return user.to_dict_with_messages(response.json()), 200
|
||||
|
||||
return f'Пользователь с uuid {uuid_} не найден', 404
|
||||
|
||||
@app.route('/check/<uuid:uuid_>', methods=['GET'])
|
||||
def check_exist(uuid_):
|
||||
for user in users:
|
||||
if user.uuid_ == uuid_:
|
||||
return '', 200
|
||||
return '', 404
|
||||
|
||||
@app.route('/', methods=['POST'])
|
||||
def create():
|
||||
data = request.json
|
||||
name = data.get('name', None)
|
||||
surname = data.get('surname', None)
|
||||
if name is None or surname is None:
|
||||
return 'Недостаточно информации для создания пользователя', 404
|
||||
|
||||
new_user = User(name, surname, None)
|
||||
users.append(new_user)
|
||||
return get_one(new_user.uuid_)
|
||||
|
||||
@app.route('/<uuid:uuid_>', methods=['PUT'])
|
||||
def update_by_id(uuid_):
|
||||
data = request.json
|
||||
new_name = data.get('name', None)
|
||||
new_surname = data.get('surname', None)
|
||||
|
||||
for user in users:
|
||||
if user.uuid_ == uuid_:
|
||||
if new_name is not None:
|
||||
user.name = new_name
|
||||
if new_surname is not None:
|
||||
user.surname = new_surname
|
||||
return get_one(user.uuid_)
|
||||
|
||||
return f'Пользователь с uuid {uuid_} не найден', 404
|
||||
|
||||
|
||||
@app.route('/<uuid:uuid_>', methods=['DELETE'])
|
||||
def delete(uuid_):
|
||||
for user in users:
|
||||
if user.uuid_ == uuid_:
|
||||
users.remove(user)
|
||||
return 'Пользователь удален', 200
|
||||
|
||||
return f'Пользователь с uuid {uuid_} не найден', 404
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
app.run(host='0.0.0.0', port=20001, debug=True)
|
||||
@ -1,34 +0,0 @@
|
||||
# Богданов Дмитрий ПИбд-42
|
||||
# Лабораторная работа №4
|
||||
|
||||
|
||||
## Предметная область:
|
||||
Автоматизация работы теплицы
|
||||
|
||||
## Результаты выполнения туториалов:
|
||||
|
||||
- Первый туториал:
|
||||
|
||||
|
||||
- Второй туториал:
|
||||
|
||||
|
||||
- Третий туториал:
|
||||
|
||||
|
||||
|
||||
## Данные из RabbitMQ:
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
### Вывод:
|
||||
Из-за моментальной обработки сообщений в Consumer2, его очередь никогда не заполняется.
|
||||
Consumer1 же тратит на обработку 2 секунды, из-за чего соответствующая очередь существенно заполняется при одном
|
||||
запущенном экземпляре.
|
||||
При нескольких запущенных экземплярах Consumer1 очередь заполняется существенно медленнее, и перестаёт заполняться совсем при определенном кол-ве запущенных экземпляров.
|
||||
|
||||
|
||||
## [Видео](https://drive.google.com/file/d/1KWHHYWiK8OX48OfhDnEKDtMz-Umfs0uj/view?usp=sharing)
|
||||
@ -1,27 +0,0 @@
|
||||
import pika
|
||||
import time
|
||||
|
||||
|
||||
def callback(ch, method, properties, body):
|
||||
print(f'Receiver 1: получено сообщение. {body.decode()}')
|
||||
|
||||
time.sleep(3)
|
||||
|
||||
print('Receiver 1 закончил обработку')
|
||||
|
||||
|
||||
def consume_events_1():
|
||||
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost', port=5672, credentials=pika.PlainCredentials("user", "password")))
|
||||
channel = connection.channel()
|
||||
|
||||
channel.queue_declare(queue='receiver1_queue')
|
||||
channel.queue_bind(exchange='greenhouse_events', queue='receiver1_queue')
|
||||
|
||||
channel.basic_consume(queue='receiver1_queue', on_message_callback=callback, auto_ack=True)
|
||||
|
||||
print('Ожидание сообщения...')
|
||||
channel.start_consuming()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
consume_events_1()
|
||||
@ -1,24 +0,0 @@
|
||||
import pika
|
||||
|
||||
|
||||
def callback(ch, method, properties, body):
|
||||
print(f'Receiver 2: получено сообщение. {body.decode()}')
|
||||
|
||||
print('Receiver 2 закончил обработку')
|
||||
|
||||
|
||||
def consume_events_2():
|
||||
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost', port=5672, credentials=pika.PlainCredentials("user", "password")))
|
||||
channel = connection.channel()
|
||||
|
||||
channel.queue_declare(queue='receiver2_queue')
|
||||
channel.queue_bind(exchange='greenhouse_events', queue='receiver2_queue')
|
||||
|
||||
channel.basic_consume(queue='receiver2_queue', on_message_callback=callback, auto_ack=True)
|
||||
|
||||
print('Ожидание сообщения...')
|
||||
channel.start_consuming()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
consume_events_2()
|
||||
@ -1,25 +0,0 @@
|
||||
import pika
|
||||
import time
|
||||
|
||||
def publish_events():
|
||||
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost', port=5672, credentials=pika.PlainCredentials("user", "password")))
|
||||
channel = connection.channel()
|
||||
|
||||
channel.exchange_declare(exchange='greenhouse_events', exchange_type='fanout')
|
||||
|
||||
events = [
|
||||
"Влажность превысила верхнюю границу",
|
||||
"Влажность упала за нижнюю границу",
|
||||
"Полив начат",
|
||||
"Полив остановлен"
|
||||
]
|
||||
|
||||
while True:
|
||||
event = events[int(time.time()) % len(events)]
|
||||
channel.basic_publish(exchange='greenhouse_events', routing_key='', body=event)
|
||||
print(f'Отправлено: {event}')
|
||||
time.sleep(1)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
publish_events()
|
||||
@ -1,25 +0,0 @@
|
||||
import pika, sys, os
|
||||
|
||||
def main():
|
||||
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost', port=5672, credentials=pika.PlainCredentials("user", "password")))
|
||||
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)
|
||||
@ -1,13 +0,0 @@
|
||||
import pika
|
||||
|
||||
connection = pika.BlockingConnection(pika.ConnectionParameters(host='localhost', port=5672, credentials=pika.PlainCredentials("user", "password")))
|
||||
channel = connection.channel()
|
||||
|
||||
channel.queue_declare('hello')
|
||||
|
||||
channel.basic_publish(exchange='',
|
||||
routing_key='hello',
|
||||
body='Hello world!')
|
||||
print(" [x] Sent 'Hello world!'")
|
||||
|
||||
connection.close()
|
||||
@ -1,19 +0,0 @@
|
||||
import pika
|
||||
import sys
|
||||
|
||||
connection = pika.BlockingConnection(
|
||||
pika.ConnectionParameters(host='localhost', port=5672, credentials=pika.PlainCredentials("user", "password")))
|
||||
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()
|
||||
@ -1,22 +0,0 @@
|
||||
import pika
|
||||
import time
|
||||
|
||||
connection = pika.BlockingConnection(
|
||||
pika.ConnectionParameters(host='localhost', port=5672, credentials=pika.PlainCredentials("user", "password")))
|
||||
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()
|
||||
@ -1,13 +0,0 @@
|
||||
import pika
|
||||
import sys
|
||||
|
||||
connection = pika.BlockingConnection(
|
||||
pika.ConnectionParameters(host='localhost', port=5672, credentials=pika.PlainCredentials("user", "password")))
|
||||
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()
|
||||
@ -1,22 +0,0 @@
|
||||
import pika
|
||||
|
||||
connection = pika.BlockingConnection(
|
||||
pika.ConnectionParameters(host='localhost', port=5672, credentials=pika.PlainCredentials("user", "password")))
|
||||
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()
|
||||
@ -1,12 +0,0 @@
|
||||
version: '3.8'
|
||||
|
||||
services:
|
||||
rabbitmq:
|
||||
image: rabbitmq:3-management
|
||||
container_name: rabbitmq
|
||||
environment:
|
||||
RABBITMQ_DEFAULT_USER: user
|
||||
RABBITMQ_DEFAULT_PASS: password
|
||||
ports:
|
||||
- "5672:5672"
|
||||
- "15672:15672"
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 38 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 33 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 28 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 29 KiB |
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user