add competition service (it`s broken, I will fix it later)

internal/competition/server/server.go

@@ -0,0 +1,143 @@
+package server
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"net"
+	"net/http"
+	"time"
+
+	"datarush/internal/competition/config"
+	grpcHandlers "datarush/internal/competition/handler/grpc"
+	"datarush/internal/competition/repository/postgres"
+	"datarush/internal/competition/service"
+	pb "datarush/pkg/api/competition"
+
+	"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
+	"github.com/jmoiron/sqlx"
+	_ "github.com/lib/pq"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/grpc/reflection"
+)
+
+const (
+	httpReadTimeout  = 10 * time.Second
+	httpWriteTimeout = 10 * time.Second
+	httpIdleTimeout  = 60 * time.Second
+)
+
+type Server struct {
+	grpcServer *grpc.Server
+	httpServer *http.Server
+	config     *config.Config
+	db         *sqlx.DB
+}
+
+func New(cfg *config.Config) *Server {
+	return &Server{
+		config: cfg,
+	}
+}
+
+func (s *Server) Start() error {
+	db, err := sqlx.Connect("postgres", s.config.BuildPostgresConnStr())
+	if err != nil {
+		return fmt.Errorf("failed to connect to postgres: %w", err)
+	}
+	s.db = db
+
+	go func() {
+		if err := s.startGRPCServer(); err != nil {
+			log.Fatalf("failed to start gRPC server: %v", err)
+		}
+	}()
+
+	go func() {
+		if err := s.startHTTPServer(); err != nil {
+			log.Fatalf("failed to start HTTP server: %v", err)
+		}
+	}()
+
+	log.Println("competition service started")
+	return nil
+}
+
+func (s *Server) startGRPCServer() error {
+	lis, err := net.Listen("tcp", fmt.Sprintf(":%d", s.config.GRPCPort))
+	if err != nil {
+		return fmt.Errorf("failed to listen on grpc port: %w", err)
+	}
+
+	s.grpcServer = grpc.NewServer()
+	s.registerGRPCServices()
+
+	log.Printf("starting gRPC server on port %d", s.config.GRPCPort)
+	return s.grpcServer.Serve(lis)
+}
+
+func (s *Server) registerGRPCServices() {
+	compRepo := postgres.NewCompetitionRepository(s.db.DB, nil, false)
+	compService := service.NewService(compRepo)
+	compHandler := grpcHandlers.NewCompetitionHandler(compService)
+
+	pb.RegisterCompetitionServiceServer(s.grpcServer, compHandler)
+
+	if s.config.GRPCEnableReflection {
+		reflection.Register(s.grpcServer)
+	}
+}
+
+func (s *Server) startHTTPServer() error {
+	ctx := context.Background()
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	mux := runtime.NewServeMux()
+	opts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
+	grpcEndpoint := fmt.Sprintf("localhost:%d", s.config.GRPCPort)
+
+	err := pb.RegisterCompetitionServiceHandlerFromEndpoint(ctx, mux, grpcEndpoint, opts)
+	if err != nil {
+		return fmt.Errorf("failed to register http handlers: %w", err)
+	}
+
+	s.httpServer = &http.Server{
+		Addr:         fmt.Sprintf(":%d", s.config.HTTPPort),
+		Handler:      mux,
+		ReadTimeout:  httpReadTimeout,
+		WriteTimeout: httpWriteTimeout,
+		IdleTimeout:  httpIdleTimeout,
+	}
+
+	log.Printf("starting HTTP server on port %d", s.config.HTTPPort)
+	return s.httpServer.ListenAndServe()
+}
+
+func (s *Server) Stop() {
+	log.Println("shutting down competition server...")
+
+	// Shutdown HTTP server
+	if s.httpServer != nil {
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		if err := s.httpServer.Shutdown(ctx); err != nil {
+			log.Printf("failed to shutdown HTTP server gracefully: %v", err)
+		}
+	}
+
+	// Shutdown gRPC server
+	if s.grpcServer != nil {
+		s.grpcServer.GracefulStop()
+	}
+
+	// Close database connection
+	if s.db != nil {
+		if err := s.db.Close(); err != nil {
+			log.Printf("failed to close database connection: %v", err)
+		}
+	}
+
+	log.Println("competition server stopped")
+}