ruspet_portal_back/service/rest_base_service/cmd/app.go

173 lines
5.2 KiB
Go

package main
import (
configcore "bitrix_balancer_api/core/config"
clientcontrollers "bitrix_balancer_api/core/lib/internally/client-controllers"
"bitrix_balancer_api/core/lib/internally/redis"
"bitrix_balancer_api/core/utilscore"
balancerhandler "bitrix_balancer_api/rest_base_service/handler/balancer"
"bitrix_balancer_api/rest_base_service/types"
"errors"
"fmt"
"github.com/go-chi/chi/v5"
"github.com/go-chi/chi/v5/middleware"
"github.com/go-chi/cors"
"github.com/go-chi/httprate"
"github.com/sirupsen/logrus"
"log"
"net"
"net/http"
"time"
)
const (
readTimeout = 15 * time.Minute // Таймаут чтения
writeTimeout = 15 * time.Minute // Таймаут записи
idleTimeout = 15 * time.Minute // Таймаут бездействия
rateLimit = 25 // Лимит запросов
rateWindow = 1 * time.Second // Окно времени для лимита запросов
)
func main() {
// Получение конфигурации приложения
appConfig, clientsExternal, err := getClientsExternal()
if err != nil {
logrus.Error("error getting external clients", err)
return
}
// ** Инициализация модулей
ipc, err := initInternalProvider(appConfig, clientsExternal)
if err != nil {
logrus.Error("error initializing internal provider", err)
return
}
decreasePerSec := redismodule.QuotaDecreaseDefault
if appConfig.Bitrix.IsEnterprise {
decreasePerSec = redismodule.QuotaDecreaseEnterprise
}
go ipc.RedisClient.StartQuotaLeaker(ipc.Config.Bitrix.PortalID, decreasePerSec)
startRest(ipc)
}
func getClientsExternal() (*configcore.Config, clientcontrollers.ClientsExternal, error) {
options := &configcore.ConfigLoadOptions{
Redis: true,
Bitrix: true,
Secrets: true,
Server: configcore.ExposedServiceOptions{
RESTBaseService: true,
},
}
return clientcontrollers.ReturnClientsExternal(options)
}
func initInternalProvider(cfg *configcore.Config, clientsExternal clientcontrollers.ClientsExternal) (*types.InternalProviderControl, error) {
return &types.InternalProviderControl{
Config: cfg,
RedisClient: clientsExternal.Redis,
}, nil
}
// запуск сервера REST API
func startRest(ipc *types.InternalProviderControl) {
router := chi.NewRouter()
corsOptions := cors.New(cors.Options{
AllowedOrigins: []string{"*"},
AllowedMethods: []string{http.MethodGet, http.MethodPost, http.MethodPut, http.MethodDelete, http.MethodOptions},
AllowedHeaders: []string{"Accept", "Authorization", "Content-Type", "Cache-Control", "X-Requested-With", "x-api"},
ExposedHeaders: []string{"Link", "Cache-Control"},
AllowCredentials: false,
MaxAge: 300, // Максимальное время жизни предварительных запросов в секундах
})
router.Use(corsOptions.Handler)
router.Use(middleware.RealIP)
// Глобальный перехват паник, чтобы сервис продолжал работать
router.Use(utilscore.RecoverMiddleware())
// Добавляем ограничение по IP
router.Use(httprate.LimitByIP(rateLimit, rateWindow))
// Регистрация обработчиков
err := registerRoutes(router, ipc)
if err != nil {
logrus.Error(err)
return
}
serverBind := ipc.Config.Server.RESTBaseService.BindRest
serverPort := ipc.Config.Server.RESTBaseService.PortRest
if serverBind == "" || serverPort == 0 {
log.Fatal(errors.New("rest_base_service: missed bind or port params"))
}
serverStartURI := fmt.Sprintf("%s:%d",
serverBind,
serverPort)
listener, err := net.Listen("tcp", serverStartURI)
if err != nil {
logrus.Error("🛑 error start listener: ", err)
log.Fatal(err)
}
httpServer := &http.Server{
Handler: router,
ReadTimeout: readTimeout,
WriteTimeout: writeTimeout,
IdleTimeout: idleTimeout,
}
log.Println("✅ Application initialized and started: ", serverStartURI)
if err := httpServer.Serve(listener); err != nil {
switch {
case errors.Is(err, http.ErrServerClosed):
logrus.Error("🛑 Server shutdown")
default:
log.Fatal(err)
}
}
}
// регистрирует маршруты
func registerRoutes(router chi.Router, ipc *types.InternalProviderControl) error {
// Слайс обработчиков маршрутов
routeHandlers := []struct {
name string
handler func(chi.Router, *types.InternalProviderControl) error
}{
{"balancer_base", balancerhandler.RegisterBalancerRoutes},
}
// Регистрация всех маршрутов
for _, rh := range routeHandlers {
if errObj := rh.handler(router, ipc); errObj != nil {
logrus.Errorln("🔴 failed to register", rh.name, "routes:", errObj)
return fmt.Errorf("🔴 failed to register %s routes", rh.name)
}
}
// Вывод зарегистрированных маршрутов
if err := printRoutes(router); err != nil {
logrus.Errorln("🔴 failed to print routes:", err)
return fmt.Errorf("🔴 failed to print routes: %w", err)
}
return nil
}
func printRoutes(r chi.Router) error {
err := chi.Walk(r, func(method, route string, handler http.Handler, middlewares ...func(http.Handler) http.Handler) error {
return nil
})
if err != nil {
logrus.Error("failed to walk routes: ", err)
return err
}
return nil
}