add package privilege

.env.test

@@ -1,4 +0,0 @@
-HTTP_PORT = 8080
-HTTP_HOST=localhost
-ADMIN_GET_PRIVILEGE_URL = http://localhost:8081/privilege
-ADMIN_POST_PRIVILEGE_URL = http://localhost:8081/privilege

cmd/main.go

@@ -1,55 +0,0 @@
-package main
-
-import (
-	"github.com/gofiber/fiber/v2"
-	"github.com/sirupsen/logrus"
-	"os"
-	"os/signal"
-	"penahub.gitlab.yandexcloud.net/backend/penahub_common/privilege/client"
-	"penahub.gitlab.yandexcloud.net/backend/penahub_common/privilege/config"
-	"penahub.gitlab.yandexcloud.net/backend/penahub_common/privilege/controller"
-)
-
-func main() {
-	logger := logrus.New()
-
-	cfg, err := config.LoadConfig()
-	if err != nil {
-		logger.Fatal("Error loading configuration:", err)
-	}
-
-	hubAdminClient := client.NewHubAdminClient(&client.HubAdminClientDeps{
-		Logger: logger,
-		URLs: &config.AdminMicroServiceURL{
-			GetPrivilege:  cfg.AdminGetPrivilege,
-			PostPrivilege: cfg.AdminPostPrivilege,
-		},
-	})
-
-	privilegeController := controller.NewPrivilegeController(logger, hubAdminClient)
-
-	app := fiber.New()
-
-	app.Post("/check", privilegeController.Check)
-
-	go gracefulShutdown(app, logger)
-
-	err = app.Listen(cfg.HTTPHost + ":" + cfg.HTTPPort)
-	if err != nil {
-		logger.Fatal("Error starting Fiber app:", err)
-	}
-}
-
-func gracefulShutdown(app *fiber.App, logger *logrus.Logger) {
-	c := make(chan os.Signal, 1)
-	signal.Notify(c, os.Interrupt, os.Kill)
-
-	<-c
-	logger.Info("Shutting down...")
-
-	if err := app.Shutdown(); err != nil {
-		logger.Error("Graceful shutdown failed:", err)
-	} else {
-		logger.Info("Graceful shutdown completed")
-	}
-}

privilege/client/hubadmin.go

@@ -1,105 +0,0 @@
-package client
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"github.com/sirupsen/logrus"
-	"io"
-	"net/http"
-	"penahub.gitlab.yandexcloud.net/backend/penahub_common/privilege/config"
-)
-
-type HubAdminClientDeps struct {
-	Logger *logrus.Logger
-	URLs   *config.AdminMicroServiceURL
-}
-
-type HubAdminClient struct {
-	logger *logrus.Logger
-	urls   *config.AdminMicroServiceURL
-}
-
-func NewHubAdminClient(deps *HubAdminClientDeps) *HubAdminClient {
-	return &HubAdminClient{
-		logger: deps.Logger,
-		urls:   deps.URLs,
-	}
-}
-
-func (receiver *HubAdminClient) GetPrivilege(ctx context.Context) ([]config.Privilege, error) {
-	hubAdminURL := receiver.urls.GetPrivilege
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, hubAdminURL, nil)
-	if err != nil {
-		receiver.logger.Errorf("failed to create GET request: %v", err)
-		return nil, err
-	}
-
-	response, err := http.DefaultClient.Do(req)
-	if err != nil {
-		receiver.logger.Errorf("failed to get privilege on <GetPrivilege> of <HubAdminClient>: %v", err)
-		return nil, err
-	}
-	defer response.Body.Close()
-
-	if response.StatusCode != http.StatusOK {
-		return nil, errors.New("unexpected status code")
-	}
-
-	var buffer bytes.Buffer
-	if _, err := io.Copy(&buffer, response.Body); err != nil {
-		receiver.logger.Errorf("failed to read response body: %v", err)
-		return nil, err
-	}
-
-	var privileges []config.Privilege
-	if err := json.Unmarshal(buffer.Bytes(), &privileges); err != nil {
-		receiver.logger.Errorf("failed to unmarshal response body: %v", err)
-		return nil, err
-	}
-
-	return privileges, nil
-}
-
-func (receiver *HubAdminClient) PostPrivilege(ctx context.Context, data []config.Privilege) ([]config.Privilege, error) {
-	postPrivilegeURL := receiver.urls.PostPrivilege
-
-	payload, err := json.Marshal(data)
-	if err != nil {
-		receiver.logger.Errorf("failed to marshal request body: %v", err)
-		return nil, err
-	}
-
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, postPrivilegeURL, bytes.NewBuffer(payload))
-	if err != nil {
-		receiver.logger.Errorf("failed to create POST request: %v", err)
-		return nil, err
-	}
-	req.Header.Set("Content-Type", "application/json")
-
-	response, err := http.DefaultClient.Do(req)
-	if err != nil {
-		receiver.logger.Errorf("failed to post privilege on <PostPrivilege> of <HubAdminClient>: %v", err)
-		return nil, err
-	}
-	defer response.Body.Close()
-
-	if response.StatusCode != http.StatusOK {
-		return nil, errors.New("unexpected status code")
-	}
-
-	var buffer bytes.Buffer
-	if _, err := io.Copy(&buffer, response.Body); err != nil {
-		receiver.logger.Errorf("failed to read response body: %v", err)
-		return nil, err
-	}
-
-	var privileges []config.Privilege
-	if err := json.Unmarshal(buffer.Bytes(), &privileges); err != nil {
-		receiver.logger.Errorf("failed to unmarshal response body: %v", err)
-		return nil, err
-	}
-
-	return privileges, nil
-}

privilege/config/config.go

@@ -1,29 +0,0 @@
-package config
-
-import (
-	"github.com/joho/godotenv"
-	"log"
-	"os"
-)
-
-type Config struct {
-	HTTPPort           string
-	HTTPHost           string
-	AdminGetPrivilege  string
-	AdminPostPrivilege string
-}
-
-func LoadConfig() (*Config, error) {
-	err := godotenv.Load("./env.test")
-	if err != nil {
-		log.Fatal("Error loading .env file")
-		return nil, err
-	}
-
-	return &Config{
-		HTTPPort:           os.Getenv("HTTP_PORT"),
-		HTTPHost:           os.Getenv("HTTP_HOST"),
-		AdminGetPrivilege:  os.Getenv("ADMIN_GET_PRIVILEGE_URL"),
-		AdminPostPrivilege: os.Getenv("ADMIN_POST_PRIVILEGE_URL"),
-	}, nil
-}

privilege/config/model.go

@@ -17,13 +17,3 @@ type Privilege struct {
 	UpdatedAt   time.Time `json:"updatedAt"`
 	DeletedAt   time.Time `json:"deletedAt"`
 }
-
-type RequestParams struct {
-	ServiceName string      `json:"service"`
-	Privileges  []Privilege `json:"privileges"`
-}
-
-type AdminMicroServiceURL struct {
-	GetPrivilege  string
-	PostPrivilege string
-}

privilege/controller/privilege.go

@@ -1,55 +1,87 @@
-package controller
+package privilege
 
 import (
-	"github.com/gofiber/fiber/v2"
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
 	"github.com/sirupsen/logrus"
+	"io"
 	"net/http"
-	"penahub.gitlab.yandexcloud.net/backend/penahub_common/privilege/client"
 	"penahub.gitlab.yandexcloud.net/backend/penahub_common/privilege/config"
 )
 
-type Controller struct {
+type Deps struct {
-	logger   *logrus.Logger
+	Logger *logrus.Logger
-	hubAdmin *client.HubAdminClient
 }
 
-func NewPrivilegeController(logger *logrus.Logger, hubAdmin *client.HubAdminClient) *Controller {
+type Handler struct {
-	return &Controller{
+	logger *logrus.Logger
-		logger:   logger,
+}
-		hubAdmin: hubAdmin,
+
+func NewPrivilegeHandler(deps *Deps) *Handler {
+	return &Handler{
+		logger: deps.Logger,
 	}
 }
 
-func (receiver *Controller) Check(c *fiber.Ctx) error {
+func (handler *Handler) GetPrivilege(ctx context.Context, url string) ([]config.Privilege, error) {
-	ctx := c.Context()
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
-
-	var requestParams config.RequestParams
-	if err := c.BodyParser(&requestParams); err != nil {
-		receiver.logger.Errorf("failed to parse request body: %v", err)
-		return c.Status(http.StatusBadRequest).JSON(map[string]string{"error": "invalid request body"})
-	}
-
-	existingPrivileges, err := receiver.hubAdmin.GetPrivilege(ctx)
 	if err != nil {
-		receiver.logger.Errorf("failed to get existing privileges: %v", err)
+		handler.logger.Errorf("failed to create GET request: %v", err)
-		return c.Status(http.StatusInternalServerError).JSON(map[string]string{"error": "failed to get existing privileges"})
+		return nil, err
 	}
 
-	updatedPrivileges := compareAndMergePrivileges(existingPrivileges, requestParams.Privileges)
+	return handler.doRequest(req)
-	if len(updatedPrivileges) == 0 {
-		return c.Status(http.StatusOK).JSON("no updates")
-	}
-
-	_, err = receiver.hubAdmin.PostPrivilege(ctx, updatedPrivileges)
-	if err != nil {
-		receiver.logger.Errorf("failed to post privileges: %v", err)
-		return c.Status(http.StatusInternalServerError).JSON(map[string]string{"error": "failed to post privileges"})
-	}
-
-	return c.Status(http.StatusOK).JSON(map[string][]config.Privilege{"successful registration": updatedPrivileges})
 }
 
-func compareAndMergePrivileges(existing []config.Privilege, incoming []config.Privilege) []config.Privilege {
+func (handler *Handler) PostPrivilege(ctx context.Context, data []config.Privilege, url string) ([]config.Privilege, error) {
+
+	payload, err := json.Marshal(data)
+	if err != nil {
+		handler.logger.Errorf("failed to marshal request body: %v", err)
+		return nil, err
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewBuffer(payload))
+	if err != nil {
+		handler.logger.Errorf("failed to create POST request: %v", err)
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	return handler.doRequest(req)
+}
+
+func (handler *Handler) doRequest(req *http.Request) ([]config.Privilege, error) {
+	response, err := http.DefaultClient.Do(req)
+	if err != nil {
+		handler.logger.Errorf("failed to perform HTTP request: %v", err)
+		return nil, err
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode != http.StatusOK {
+		return nil, errors.New("unexpected status code")
+	}
+
+	var buffer bytes.Buffer
+	if _, err := io.Copy(&buffer, response.Body); err != nil {
+		handler.logger.Errorf("failed to read response body: %v", err)
+		return nil, err
+	}
+
+	var privileges []config.Privilege
+	if err := json.Unmarshal(buffer.Bytes(), &privileges); err != nil {
+		handler.logger.Errorf("failed to unmarshal response body: %v", err)
+		return nil, err
+	}
+
+	return privileges, nil
+}
+
+// return this list must be posted to Hubadmin.
+func ComparePrivileges(existing []config.Privilege, incoming []config.Privilege) []config.Privilege {
 	existingMap := make(map[string]config.Privilege)
 	result := make([]config.Privilege, 0)
 	for _, privilege := range existing {