Microservices

.env

@@ -1 +1 @@
-YAML_PATH="../../internal/configs/config.yaml"
+YAML_PATH="internal/configs/config.yaml"

.github/workflows/ci.yml

@@ -3,7 +3,6 @@ name: CI
 on:
   push:
     branches: [ backend-dev ]
-  pull_request:
 
 jobs:
   lint:

Makefile

@@ -1,27 +1,67 @@
-all: run clean
+all: clean run
 
 .PHONY: run
-run: ## Run project
-	docker compose up
+run:
+	cd docker && docker compose up -d
 
-.PHONY: clean
-clean: ## Clean containers and images
+.PHONY: build
+build: |
+	go build -o cmd/auth/auth cmd/auth/main.go
+	go build -o cmd/api/api cmd/api/main.go
+	go build -o cmd/chat/chat cmd/chat/main.go
+	go build -o cmd/consumer/consumer cmd/consumer/main.go
+	go build -o cmd/producer/producer cmd/producer/main.go
+	go build -o cmd/messages/messages cmd/messages/main.go
+	go build -o cmd/user/user cmd/user/main.go
+	cd docker && docker compose up -d
+
+.PHONY: clean_microservices
+clean: |
+	docker stop api || true
+	docker stop chat || true
+	docker stop user || true
+	docker stop auth || true
+	docker stop consumer || true
+	docker stop producer || true
+	docker stop messages || true
+
+	docker rm api || true
+	docker rm chat || true
+	docker rm user || true
+	docker rm auth || true
+	docker rm consumer || true
+	docker rm producer || true
+	docker rm messages || true
+
+	docker rmi docker-api || true
+	docker rmi docker-chat || true
+	docker rmi docker-user || true
+	docker rmi docker-auth || true
+	docker rmi docker-consumer || true
+	docker rmi docker-producer || true
+	docker rmi docker-messages || true
+
+.PHONY: clean_images_containers
+clean_images_containers: |
 	docker stop $(docker ps -q)
-	docker rm -vf $(docker ps -aq)
-	docker rmi -f $(docker images -aq)
+	docker system prune -a
+
+.PHONY: generate_proto_rpc
+generate_proto_rpc: |
+	protoc --go-grpc_opt=require_unimplemented_servers=false --go-grpc_out=internal/generated protobuf/*_rpc.proto
 
-.PHONY: test
-test: ## Run all the tests
-	go test ./...
+.PHONY: generate_proto
+generate_proto: |
+	find protobuf -type f -name '*.proto' ! -name '*_rpc.proto' -exec protoc --go_out=internal/generated {} +
 
 .PHONY: cover_out
-cover_out: test ## Run all the tests and opens the coverage report
+cover_out: |
 	go test -coverprofile=c.out ./... -coverpkg=./...
-	cat c.out | grep -v "cmd" | grep -v "_mock.go" > tmp.out
+	cat c.out | grep -v "cmd" | grep -v "_mock.go" | grep -v ".pb" > tmp.out
 	go tool cover -func=tmp.out
 
 .PHONY: cover_html
-cover_html: test ## Run all the tests and opens the coverage report in HTML
+cover_html: |
 	go test -v ./... -coverprofile=c.out ./... -coverpkg=./...
 	cat c.out | grep -v "cmd" | grep -v "_mock.go" > tmp.out
 	go tool cover -html=tmp.out

README.md

@@ -15,3 +15,6 @@
 
 Ментор по беку - [Олег Реуцкий](https://github.com/astlok)  
 Ментор по фронту - [Антон Елагин](https://github.com/AntonElagin)
+
+## Статус последнего деплоя:
+<br><img src="https://github.com/go-park-mail-ru/2023_1_Brigade/workflows/CI/badge.svg?branch=main"><br>

cmd/api/main.go

@@ -1,46 +1,43 @@
 package main
 
 import (
-	"github.com/go-redis/redis"
-	_ "github.com/go-sql-driver/mysql"
 	"github.com/jmoiron/sqlx"
 	"github.com/joho/godotenv"
+	"github.com/labstack/echo-contrib/prometheus"
 	"github.com/labstack/echo/v4"
 	"github.com/labstack/echo/v4/middleware"
 	_ "github.com/lib/pq"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"github.com/redis/go-redis/v9"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
 	"gopkg.in/yaml.v2"
 	"os"
+	clientAuth "project/internal/clients/auth"
+	clientChat "project/internal/clients/chat"
+	clientMessages "project/internal/clients/messages"
+	clientUser "project/internal/clients/user"
 
-	"github.com/minio/minio-go/v7"
-	"github.com/minio/minio-go/v7/pkg/credentials"
-	myMiddleware "project/internal/middleware"
+	httpUser "project/internal/user/delivery/http"
 
 	"project/internal/configs"
+	wsMessages "project/internal/messages/delivery/ws"
+	myMiddleware "project/internal/middleware"
 
 	log "github.com/sirupsen/logrus"
+
+	usecaseAuthSession "project/internal/auth/session/usecase"
 	httpAuthUser "project/internal/auth/user/delivery/http"
 	httpChat "project/internal/chat/delivery/http"
 	httpImages "project/internal/images/delivery/http"
-	wsMessages "project/internal/messages/delivery/ws"
-	httpUser "project/internal/user/delivery/http"
-
-	usecaseAuthSession "project/internal/auth/session/usecase"
-	usecaseAuthUser "project/internal/auth/user/usecase"
-	usecaseChat "project/internal/chat/usecase"
 	usecaseImages "project/internal/images/usecase"
-	usecaseMessages "project/internal/messages/usecase"
-	usecaseUser "project/internal/user/usecase"
 
 	repositoryAuthSession "project/internal/auth/session/repository"
-	repositoryAuthUser "project/internal/auth/user/repository"
-	repositoryChat "project/internal/chat/repository"
 	repositoryImages "project/internal/images/repository"
-	repositoryMessages "project/internal/messages/repository"
-	repositoryUser "project/internal/user/repository"
 )
 
 func init() {
-	envPath := "../../.env"
+	envPath := ".env"
 	if err := godotenv.Load(envPath); err != nil {
 		log.Println("No .env file found")
 	}
@@ -60,50 +57,83 @@ func main() {
 
 	yamlPath, exists := os.LookupEnv("YAML_PATH")
 	if !exists {
-		log.Fatal("Yaml path not found")
+		log.Error("Yaml path not found")
 	}
 
 	yamlFile, err := os.ReadFile(yamlPath)
 	if err != nil {
-		log.Fatal(err)
+		log.Error(err)
 	}
 
 	var config configs.Config
 	err = yaml.Unmarshal(yamlFile, &config)
 	if err != nil {
-		log.Fatal(err)
+		log.Error(err)
 	}
 
-	db, err := sqlx.Open(config.Postgres.DB, config.Postgres.ConnectionToDB) // ping
+	db, err := sqlx.Open(config.Postgres.DB, config.Postgres.ConnectionToDB)
 	if err != nil {
-		log.Fatal(err)
+		log.Error(err)
 	}
+	defer db.Close()
+
+	db.SetMaxIdleConns(10)
+	db.SetMaxOpenConns(10)
 
 	redis := redis.NewClient(&redis.Options{
 		Addr: config.Redis.Addr,
 	})
+	defer redis.Close()
 
-	minioClient, err := minio.New(config.Minio.Endpoint, &minio.Options{
-		Creds: credentials.NewStaticV4(config.Minio.Username, config.Minio.Password, config.Minio.Token),
-	})
+	grpcConnChats, err := grpc.Dial(
+		config.ChatsService.Addr,
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+		grpc.WithBlock(),
+	)
+	if err != nil {
+		log.Error("cant connect to grpc ", err)
+	}
+	defer grpcConnChats.Close()
 
+	grpcConnUsers, err := grpc.Dial(
+		config.UsersService.Addr,
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+		grpc.WithBlock(),
+	)
 	if err != nil {
-		log.Fatal(err)
-		return
+		log.Error("cant connect to grpc ", err)
 	}
+	defer grpcConnUsers.Close()
 
-	userRepository := repositoryUser.NewUserMemoryRepository(db)
-	chatRepository := repositoryChat.NewChatMemoryRepository(db)
-	imagesRepostiory := repositoryImages.NewImagesMemoryRepository(minioClient)
-	messagesRepository := repositoryMessages.NewMessagesMemoryRepository(db)
-	authUserRepository := repositoryAuthUser.NewAuthUserMemoryRepository(db)
+	grpcConnMessages, err := grpc.Dial(
+		config.MessagesService.Addr,
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+		grpc.WithBlock(),
+	)
+	if err != nil {
+		log.Error("cant connect to grpc ", err)
+	}
+	defer grpcConnMessages.Close()
+
+	grpcConnAuth, err := grpc.Dial(
+		config.AuthService.Addr,
+		grpc.WithTransportCredentials(insecure.NewCredentials()),
+		grpc.WithBlock(),
+	)
+	if err != nil {
+		log.Error("cant connect to grpc ", err)
+	}
+	defer grpcConnAuth.Close()
+
+	authService := clientAuth.NewAuthUserServiceGRPSClient(grpcConnAuth)
+	chatService := clientChat.NewChatServiceGRPSClient(grpcConnChats)
+	userService := clientUser.NewUserServiceGRPSClient(grpcConnUsers)
+	messagesService := clientMessages.NewMessagesServiceGRPSClient(grpcConnMessages)
+
+	imagesRepostiory := repositoryImages.NewImagesMemoryRepository(db)
 	authSessionRepository := repositoryAuthSession.NewAuthSessionMemoryRepository(redis)
 
-	userUsecase := usecaseUser.NewUserUsecase(userRepository, authUserRepository)
-	authUserUsecase := usecaseAuthUser.NewAuthUserUsecase(authUserRepository, userRepository)
 	authSessionUsecase := usecaseAuthSession.NewAuthUserUsecase(authSessionRepository)
-	chatUsecase := usecaseChat.NewChatUsecase(chatRepository, userRepository)
-	messagesUsecase := usecaseMessages.NewMessagesUsecase(messagesRepository, config.Kafka)
 	imagesUsecase := usecaseImages.NewChatUsecase(imagesRepostiory)
 
 	e := echo.New()
@@ -112,16 +142,36 @@ func main() {
 		AllowOrigins:     config.Cors.AllowOrigins,
 		AllowCredentials: config.Cors.AllowCredentials,
 		AllowHeaders:     config.Cors.AllowHeaders,
+		ExposeHeaders:    config.Cors.ExposeHeaders,
 	}))
+
+	//e.Use(middleware.CSRFWithConfig(middleware.CSRFConfig{
+	//	TokenLookup:    "header:X-Csrf-Token",
+	//	CookieSecure:   true,
+	//	CookieHTTPOnly: true,
+	//	CookiePath:     "/",
+	//}))
+
 	e.Use(myMiddleware.LoggerMiddleware)
-	//e.Use(myMiddleware.XSSMidlleware)
-	//e.Use(myMiddleware.AuthMiddleware(authSessionUsecase))
-
-	httpUser.NewUserHandler(e, userUsecase)
-	httpAuthUser.NewAuthHandler(e, authUserUsecase, authSessionUsecase, userUsecase)
-	httpChat.NewChatHandler(e, chatUsecase, userUsecase)
-	wsMessages.NewMessagesHandler(e, messagesUsecase)
-	httpImages.NewImagesHandler(e, imagesUsecase)
+	e.Use(myMiddleware.AuthMiddleware(authSessionUsecase))
+
+	p := prometheus.NewPrometheus("echo", nil)
+	eProtheus := echo.New()
+
+	e.Use(p.HandlerFunc)
+	eProtheus.GET("/metrics", echo.WrapHandler(promhttp.Handler()))
+	go func() {
+		err := eProtheus.Start(":8079")
+		if err != nil {
+			log.Error(err)
+		}
+	}()
+
+	httpUser.NewUserHandler(e, userService)
+	httpAuthUser.NewAuthHandler(e, authService, authSessionUsecase, userService)
+	httpChat.NewChatHandler(e, chatService, userService)
+	wsMessages.NewMessagesHandler(e, messagesService)
+	httpImages.NewImagesHandler(e, userService, imagesUsecase)
 
 	e.Logger.Fatal(e.Start(config.Server.Port))
 }