fixes after review: handler properly auth middleware per endpoint

api/groups/baseGroup.go

@@ -14,6 +14,14 @@ var log = logger.GetOrCreate("api/groups")
 type baseGroup struct {
 	endpoints             []*shared.EndpointHandlerData
 	additionalMiddlewares []gin.HandlerFunc
+	authMiddleware        gin.HandlerFunc
+}
+
+func newBaseGroup() *baseGroup {
+	return &baseGroup{
+		additionalMiddlewares: make([]gin.HandlerFunc, 0),
+		authMiddleware:        func(ctx *gin.Context) {},
+	}
 }
 
 // RegisterRoutes will register all the endpoints to the given web server
@@ -28,19 +36,29 @@ func (bg *baseGroup) RegisterRoutes(
 			continue
 		}
 
+		handlers := make([]gin.HandlerFunc, 0)
+
 		if isAuthEnabled {
-			ws.Use(bg.GetAdditionalMiddlewares()...)
+			handlers = append(handlers, bg.GetAuthMiddleware())
 		}
 
-		ws.Handle(handlerData.Method, handlerData.Path, handlerData.Handler)
+		handlers = append(handlers, bg.GetAdditionalMiddlewares()...)
+		handlers = append(handlers, handlerData.Handler)
+
+		ws.Handle(handlerData.Method, handlerData.Path, handlers...)
 	}
 }
 
-// GetAdditionalMiddlewares return additional middlewares
+// GetAdditionalMiddlewares returns additional middlewares
 func (bg *baseGroup) GetAdditionalMiddlewares() []gin.HandlerFunc {
 	return bg.additionalMiddlewares
 }
 
+// GetAuthMiddleware returns auth middleware
+func (bg *baseGroup) GetAuthMiddleware() gin.HandlerFunc {
+	return bg.authMiddleware
+}
+
 func getEndpointStatus(
 	ws *gin.RouterGroup,
 	path string,

api/groups/eventsGroup.go

@@ -29,10 +29,8 @@ func NewEventsGroup(facade EventsFacadeHandler) (*eventsGroup, error) {
 	}
 
 	h := &eventsGroup{
-		facade: facade,
-		baseGroup: &baseGroup{
-			additionalMiddlewares: make([]gin.HandlerFunc, 0),
-		},
+		facade:    facade,
+		baseGroup: newBaseGroup(),
 	}
 
 	h.createMiddlewares()
@@ -128,18 +126,14 @@ func (h *eventsGroup) finalizedEvents(c *gin.Context) {
 }
 
 func (h *eventsGroup) createMiddlewares() {
-	var middleware []gin.HandlerFunc
-
 	user, pass := h.facade.GetConnectorUserAndPass()
 
 	if user != "" && pass != "" {
 		basicAuth := gin.BasicAuth(gin.Accounts{
 			user: pass,
 		})
-		middleware = append(middleware, basicAuth)
+		h.authMiddleware = basicAuth
 	}
-
-	h.additionalMiddlewares = middleware
 }
 
 // IsInterfaceNil returns true if there is no value under the interface

api/groups/eventsGroup_test.go

@@ -56,8 +56,7 @@ func TestNewEventsGroup(t *testing.T) {
 		eg, err := groups.NewEventsGroup(facade)
 		require.Nil(t, err)
 
-		require.Equal(t, 1, len(eg.GetAdditionalMiddlewares()))
-
+		require.NotNil(t, eg.GetAuthMiddleware())
 	})
 }
 

api/groups/hubGroup.go

@@ -27,10 +27,8 @@ func NewHubGroup(facade HubFacadeHandler) (*hubGroup, error) {
 	}
 
 	h := &hubGroup{
-		facade: facade,
-		baseGroup: &baseGroup{
-			additionalMiddlewares: make([]gin.HandlerFunc, 0),
-		},
+		facade:    facade,
+		baseGroup: newBaseGroup(),
 	}
 
 	endpoints := []*shared.EndpointHandlerData{

api/groups/statusGroup.go

@@ -27,10 +27,8 @@ func NewStatusGroup(facade shared.FacadeHandler) (*statusGroup, error) {
 	}
 
 	sg := &statusGroup{
-		facade: facade,
-		baseGroup: &baseGroup{
-			additionalMiddlewares: make([]gin.HandlerFunc, 0),
-		},
+		facade:    facade,
+		baseGroup: newBaseGroup(),
 	}
 
 	endpoints := []*shared.EndpointHandlerData{

api/shared/interface.go

@@ -41,3 +41,9 @@ type WebServerHandler interface {
 	Close() error
 	IsInterfaceNil() bool
 }
+
+// MiddlewareProcessor defines a processor used internally by the web server when processing requests
+type MiddlewareProcessor interface {
+	MiddlewareHandlerFunc() gin.HandlerFunc
+	IsInterfaceNil() bool
+}

config/config.go

@@ -78,7 +78,7 @@ type FlagsConfig struct {
 	RestApiInterface  string
 }
 
-// LoadGeneralConfig return a GeneralConfig instance by reading the provided toml file
+// LoadGeneralConfig returns a GeneralConfig instance by reading the provided toml file
 func LoadGeneralConfig(filePath string) (*GeneralConfig, error) {
 	cfg := &GeneralConfig{}
 	err := core.LoadTomlFile(cfg, filePath)
@@ -88,7 +88,7 @@ func LoadGeneralConfig(filePath string) (*GeneralConfig, error) {
 	return cfg, err
 }
 
-// LoadAPIConfig return a APIRoutesConfig instance by reading the provided toml file
+// LoadAPIConfig returns a APIRoutesConfig instance by reading the provided toml file
 func LoadAPIConfig(filePath string) (*APIRoutesConfig, error) {
 	cfg := &APIRoutesConfig{}
 	err := core.LoadTomlFile(cfg, filePath)

redis/redlock.go

@@ -40,7 +40,7 @@ func (r *redlockWrapper) IsEventProcessed(ctx context.Context, blockHash string)
 	return r.client.SetEntry(ctx, blockHash, true, r.ttl)
 }
 
-// HasConnection return true if the redis client is connected
+// HasConnection returns true if the redis client is connected
 func (r *redlockWrapper) HasConnection(ctx context.Context) bool {
 	return r.client.IsConnected(ctx)
 }