173 lines
5.2 KiB
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
|
|
}
|