Merge pull request #111 from jkaninda/refactor

refactor: refactoring of code to meet all golangci-lint requirements

.golangci.yml

@@ -0,0 +1,44 @@
+run:
+  timeout: 5m
+  allow-parallel-runners: true
+
+issues:
+  # don't skip warning about doc comments
+  # don't exclude the default set of lint
+  exclude-use-default: false
+  # restore some of the defaults
+  # (fill in the rest as needed)
+  exclude-rules:
+    - path: "internal/*"
+      linters:
+        - dupl
+        - lll
+linters:
+  disable-all: true
+  enable:
+    - dupl
+    - errcheck
+    - copyloopvar
+    - ginkgolinter
+    - goconst
+    - gocyclo
+    - gofmt
+    #- goimports
+    - gosimple
+    - govet
+    - ineffassign
+    - lll
+    - misspell
+    - nakedret
+    - prealloc
+    - revive
+    - staticcheck
+    - typecheck
+    - unconvert
+    - unparam
+    - unused
+
+linters-settings:
+  revive:
+    rules:
+      - name: comment-spacings

cmd/config/check.go

@@ -19,9 +19,10 @@ package config
 
 import (
 	"fmt"
+	"os"
+
 	pkg "github.com/jkaninda/goma-gateway/internal"
 	"github.com/spf13/cobra"
-	"os"
 )
 
 var CheckConfigCmd = &cobra.Command{

cmd/config/config.go

@@ -18,8 +18,9 @@ package config
 
 import (
 	"fmt"
-	"github.com/spf13/cobra"
 	"os"
+
+	"github.com/spf13/cobra"
 )
 
 var Cmd = &cobra.Command{

cmd/config/init.go

@@ -17,9 +17,10 @@ limitations under the License.
 */
 import (
 	"fmt"
-	"github.com/jkaninda/goma-gateway/internal"
-	"github.com/spf13/cobra"
 	"os"
+
+	pkg "github.com/jkaninda/goma-gateway/internal"
+	"github.com/spf13/cobra"
 )
 
 var InitConfigCmd = &cobra.Command{

internal/config.go

@@ -145,14 +145,14 @@ func initConfig(configFile string) error {
 			Cors: Cors{
 				Origins: []string{"http://localhost:8080", "https://example.com"},
 				Headers: map[string]string{
-					"Access-Control-Allow-Headers":     "Origin, Authorization, Accept, Content-Type, Access-Control-Allow-Headers, X-Client-Id, X-Session-Id",
+					"Access-Control-Allow-Headers":     "Origin, Authorization, Accept, Content-Type, Access-Control-Allow-Headers",
 					"Access-Control-Allow-Credentials": "true",
 					"Access-Control-Max-Age":           "1728000",
 				},
 			},
 			Routes: []Route{
 				{
-					Name:        "Public",
+					Name:        "Example",
 					Path:        "/",
 					Methods:     []string{"GET"},
 					Destination: "https://example.com",
@@ -163,12 +163,17 @@ func initConfig(configFile string) error {
 						Timeout:         "10s",
 						HealthyStatuses: []int{200, 404},
 					},
-					Middlewares: []string{"api-forbidden-paths"},
+					DisableHostFording: true,
+					Middlewares:        []string{"block-access"},
 				},
 				{
-					Name:        "Basic auth",
+					Name: "Load balancer",
 					Path: "/protected",
-					Destination: "https://example.com",
+					Backends: []string{
+						"https://example.com",
+						"https://example2.com",
+						"https://example3.com",
+					},
 					Rewrite:     "/",
 					HealthCheck: RouteHealthCheck{},
 					Cors: Cors{
@@ -179,38 +184,7 @@ func initConfig(configFile string) error {
 							"Access-Control-Max-Age":           "1728000",
 						},
 					},
-					Middlewares: []string{"basic-auth", "api-forbidden-paths"},
+					Middlewares: []string{"basic-auth", "block-access"},
-				},
-				{
-					Path:            "/",
-					Name:            "Hostname and load balancing example",
-					Hosts:           []string{"example.com", "example.localhost"},
-					InterceptErrors: []int{404, 405, 500},
-					RateLimit:       60,
-					Backends: []string{
-						"https://example.com",
-						"https://example2.com",
-						"https://example4.com",
-					},
-					Rewrite:     "/",
-					HealthCheck: RouteHealthCheck{},
-				},
-				{
-					Path:  "/",
-					Name:  "loadBalancing example",
-					Hosts: []string{"example.com", "example.localhost"},
-					Backends: []string{
-						"https://example.com",
-						"https://example2.com",
-						"https://example4.com",
-					},
-					Rewrite: "/",
-					HealthCheck: RouteHealthCheck{
-						Path:            "/health/live",
-						HealthyStatuses: []int{200, 404},
-						Interval:        "30s",
-						Timeout:         "10s",
-					},
 				},
 			},
 		},
@@ -225,24 +199,9 @@ func initConfig(configFile string) error {
 					Username: "admin",
 					Password: "admin",
 				},
-			}, {
-				Name: "jwt",
-				Type: JWTAuth,
-				Paths: []string{
-					"/protected-access",
-					"/example-of-jwt",
-				},
-				Rule: JWTRuleMiddleware{
-					URL: "https://example.com/auth/userinfo",
-					RequiredHeaders: []string{
-						"Authorization",
-					},
-					Headers: map[string]string{},
-					Params:  map[string]string{},
-				},
 			},
 			{
-				Name: "api-forbidden-paths",
+				Name: "block-access",
 				Type: AccessMiddleware,
 				Paths: []string{
 					"/swagger-ui/*",
@@ -251,46 +210,6 @@ func initConfig(configFile string) error {
 					"/actuator/*",
 				},
 			},
-			{
-				Name: "oauth-google",
-				Type: OAuth,
-				Paths: []string{
-					"/protected",
-					"/example-of-oauth",
-				},
-				Rule: OauthRulerMiddleware{
-					ClientID:     "xxx",
-					ClientSecret: "xxx",
-					Provider:     "google",
-					JWTSecret:    "your-strong-jwt-secret | It's optional",
-					RedirectURL:  "http://localhost:8080/callback",
-					Scopes: []string{"https://www.googleapis.com/auth/userinfo.email",
-						"https://www.googleapis.com/auth/userinfo.profile"},
-					Endpoint: OauthEndpoint{},
-					State:    "randomStateString",
-				},
-			},
-			{
-				Name: "oauth-authentik",
-				Type: OAuth,
-				Paths: []string{
-					"/*",
-				},
-				Rule: OauthRulerMiddleware{
-					ClientID:     "xxxx",
-					ClientSecret: "xxxx",
-					RedirectURL:  "http://localhost:8080/callback",
-					Provider:     "custom",
-					Scopes:       []string{"email", "openid"},
-					JWTSecret:    "your-strong-jwt-secret | It's optional",
-					Endpoint: OauthEndpoint{
-						AuthURL:     "https://authentik.example.com/application/o/authorize/",
-						TokenURL:    "https://authentik.example.com/application/o/token/",
-						UserInfoURL: "https://authentik.example.com/application/o/userinfo/",
-					},
-					State: "randomStateString",
-				},
-			},
 		},
 	}
 	yamlData, err := yaml.Marshal(&conf)

internal/healthcheck.go

@@ -98,7 +98,7 @@ func (health Health) createHealthCheckJob() error {
 	_, err := c.AddFunc(expression, func() {
 		err := health.Check()
 		if err != nil {
-			logger.Error("Route %s is unhealthy: error %v", health.Name, err.Error())
+			logger.Error("Route %s is unhealthy: %v", health.Name, err.Error())
 			return
 		}
 		logger.Info("Route %s is healthy", health.Name)

internal/helpers.go

@@ -19,6 +19,7 @@ import (
 	"github.com/jkaninda/goma-gateway/pkg/logger"
 	"github.com/jkaninda/goma-gateway/util"
 	"golang.org/x/oauth2"
+	"io"
 	"net/http"
 	"time"
 )
@@ -72,7 +73,12 @@ func (oauth *OauthRulerMiddleware) getUserInfo(token *oauth2.Token) (UserInfo, e
 	if err != nil {
 		return UserInfo{}, err
 	}
-	defer resp.Body.Close()
+	defer func(Body io.ReadCloser) {
+		err := Body.Close()
+		if err != nil {
+			return
+		}
+	}(resp.Body)
 
 	// Parse the user info
 	var userInfo UserInfo

internal/metrics/prometheus.go

@@ -15,22 +15,23 @@
  *
  */
 
-package pkg
+package metrics
 
 import (
+	"net/http"
+	"strconv"
+
 	"github.com/gorilla/mux"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
-	"net/http"
-	"strconv"
 )
 
 type PrometheusRoute struct {
-	name string
+	Name string
-	path string
+	Path string
 }
 
-var totalRequests = prometheus.NewCounterVec(
+var TotalRequests = prometheus.NewCounterVec(
 	prometheus.CounterOpts{
 		Name: "http_requests_total",
 		Help: "Number of get requests.",
@@ -38,7 +39,7 @@ var totalRequests = prometheus.NewCounterVec(
 	[]string{"name", "path"},
 )
 
-var responseStatus = prometheus.NewCounterVec(
+var ResponseStatus = prometheus.NewCounterVec(
 	prometheus.CounterOpts{
 		Name: "response_status",
 		Help: "Status of HTTP response",
@@ -46,22 +47,22 @@ var responseStatus = prometheus.NewCounterVec(
 	[]string{"status"},
 )
 
-var httpDuration = promauto.NewHistogramVec(prometheus.HistogramOpts{
+var HttpDuration = promauto.NewHistogramVec(prometheus.HistogramOpts{
 	Name: "http_response_time_seconds",
 	Help: "Duration of HTTP requests.",
 }, []string{"name", "path"})
 
-func (pr PrometheusRoute) prometheusMiddleware(next http.Handler) http.Handler {
+func (pr PrometheusRoute) PrometheusMiddleware(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		path := pr.path
+		path := pr.Path
 		if len(path) == 0 {
 			route := mux.CurrentRoute(r)
 			path, _ = route.GetPathTemplate()
 		}
-		timer := prometheus.NewTimer(httpDuration.WithLabelValues(pr.name, path))
+		timer := prometheus.NewTimer(HttpDuration.WithLabelValues(pr.Name, path))
 
-		responseStatus.WithLabelValues(strconv.Itoa(http.StatusOK)).Inc()
+		ResponseStatus.WithLabelValues(strconv.Itoa(http.StatusOK)).Inc()
-		totalRequests.WithLabelValues(pr.name, path).Inc()
+		TotalRequests.WithLabelValues(pr.Name, path).Inc()
 
 		timer.ObserveDuration()
 		next.ServeHTTP(w, r)

internal/middlewares/middleware.go

@@ -42,7 +42,6 @@ func (jwtAuth JwtAuth) AuthMiddleware(next http.Handler) http.Handler {
 
 			}
 		}
-		//token := r.Header.Get("Authorization")
 		authURL, err := url.Parse(jwtAuth.AuthURL)
 		if err != nil {
 			logger.Error("Error parsing auth URL: %v", err)

internal/middlewares/rate-limit.go

@@ -29,8 +29,6 @@ func (rl *TokenRateLimiter) RateLimitMiddleware() mux.MiddlewareFunc {
 		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			if !rl.Allow() {
 				logger.Error("Too many requests from IP: %s %s %s", getRealIP(r), r.URL, r.UserAgent())
-				//RespondWithError(w, http.StatusUnauthorized, http.StatusText(http.StatusUnauthorized), basicAuth.ErrorInterceptor)
-
 				// Rate limit exceeded, return a 429 Too Many Requests response
 				w.WriteHeader(http.StatusTooManyRequests)
 				_, err := w.Write([]byte(fmt.Sprintf("%d Too many requests, API requests limit exceeded. Please try again later", http.StatusTooManyRequests)))

internal/middlewares/types.go

@@ -32,7 +32,6 @@ type RateLimiter struct {
 	clientMap  map[string]*Client
 	mu         sync.Mutex
 	origins    []string
-	//hosts      []string
 	redisBased bool
 }
 

internal/proxy.go

@@ -20,6 +20,7 @@ import (
 	"fmt"
 	"github.com/jkaninda/goma-gateway/internal/middlewares"
 	"github.com/jkaninda/goma-gateway/pkg/logger"
+	"github.com/jkaninda/goma-gateway/util"
 	"net/http"
 	"net/http/httputil"
 	"net/url"
@@ -80,12 +81,7 @@ func (proxyRoute ProxyRoute) ProxyHandler() http.HandlerFunc {
 		// Create proxy
 		proxy := httputil.NewSingleHostReverseProxy(backendURL)
 		// Rewrite
-		if proxyRoute.path != "" && proxyRoute.rewrite != "" {
+		rewritePath(r, proxyRoute)
-			// Rewrite the path
-			if strings.HasPrefix(r.URL.Path, fmt.Sprintf("%s/", proxyRoute.path)) {
-				r.URL.Path = strings.Replace(r.URL.Path, fmt.Sprintf("%s/", proxyRoute.path), proxyRoute.rewrite, 1)
-			}
-		}
 		// Custom transport with InsecureSkipVerify
 		proxy.Transport = &http.Transport{TLSClientConfig: &tls.Config{
 			InsecureSkipVerify: proxyRoute.insecureSkipVerify,
@@ -105,3 +101,13 @@ func getNextBackend(backendURLs []string) *url.URL {
 	backendURL, _ := url.Parse(backendURLs[idx])
 	return backendURL
 }
+
+// rewritePath rewrites the path if it matches the prefix
+func rewritePath(r *http.Request, proxyRoute ProxyRoute) {
+	if proxyRoute.path != "" && proxyRoute.rewrite != "" {
+		// Rewrite the path if it matches the prefix
+		if strings.HasPrefix(r.URL.Path, fmt.Sprintf("%s/", proxyRoute.path)) {
+			r.URL.Path = util.ParseURLPath(strings.Replace(r.URL.Path, fmt.Sprintf("%s/", proxyRoute.path), proxyRoute.rewrite, 1))
+		}
+	}
+}

internal/redis.go

@@ -22,13 +22,12 @@ import (
 	"github.com/jkaninda/goma-gateway/pkg/logger"
 )
 
-func (gatewayServer GatewayServer) initRedis() error {
+func (gatewayServer GatewayServer) initRedis() {
-	if gatewayServer.gateway.Redis.Addr == "" {
+	if len(gatewayServer.gateway.Redis.Addr) != 0 {
-		return nil
-	}
 		logger.Info("Initializing Redis...")
 		middlewares.InitRedis(gatewayServer.gateway.Redis.Addr, gatewayServer.gateway.Redis.Password)
-	return nil
+	}
+
 }
 
 func (gatewayServer GatewayServer) closeRedis() {

internal/route.go

@@ -17,6 +17,7 @@ limitations under the License.
 */
 import (
 	"github.com/gorilla/mux"
+	"github.com/jkaninda/goma-gateway/internal/metrics"
 	"github.com/jkaninda/goma-gateway/internal/middlewares"
 	"github.com/jkaninda/goma-gateway/pkg/logger"
 	"github.com/jkaninda/goma-gateway/util"
@@ -26,12 +27,12 @@ import (
 )
 
 func init() {
-	_ = prometheus.Register(totalRequests)
+	_ = prometheus.Register(metrics.TotalRequests)
-	_ = prometheus.Register(responseStatus)
+	_ = prometheus.Register(metrics.ResponseStatus)
-	_ = prometheus.Register(httpDuration)
+	_ = prometheus.Register(metrics.HttpDuration)
 }
 
-// Initialize the routes
+// Initialize initializes the routes
 func (gatewayServer GatewayServer) Initialize() *mux.Router {
 	gateway := gatewayServer.gateway
 	m := gatewayServer.middlewares
@@ -41,6 +42,7 @@ func (gatewayServer GatewayServer) Initialize() *mux.Router {
 	}
 	// Routes background healthcheck
 	routesHealthCheck(gateway.Routes)
+
 	r := mux.NewRouter()
 	heath := HealthCheckRoute{
 		DisableRouteHealthCheckError: gateway.DisableRouteHealthCheckError,
@@ -64,7 +66,7 @@ func (gatewayServer GatewayServer) Initialize() *mux.Router {
 		logger.Info("Block common exploits enabled")
 		r.Use(middlewares.BlockExploitsMiddleware)
 	}
-	if gateway.RateLimit > 0 {
+	if gateway.RateLimit != 0 {
 		// Add rate limit middlewares to all routes, if defined
 		rateLimit := middlewares.RateLimit{
 			Id:         "global_rate", // Generate a unique ID for routes
@@ -79,16 +81,17 @@ func (gatewayServer GatewayServer) Initialize() *mux.Router {
 		r.Use(limiter.RateLimitMiddleware())
 	}
 	for rIndex, route := range gateway.Routes {
-		if route.Path != "" {
+		if len(route.Path) != 0 {
-			if route.Destination == "" && len(route.Backends) == 0 {
+			// Checks if route destination and backend are empty
+			if len(route.Destination) == 0 && len(route.Backends) == 0 {
 				logger.Fatal("Route %s : destination or backends should not be empty", route.Name)
 
 			}
-			// Apply middlewares to route
+			// Apply middlewares to the route
-			for _, mid := range route.Middlewares {
+			for _, middleware := range route.Middlewares {
-				if mid != "" {
+				if middleware != "" {
 					// Get Access middlewares if it does exist
-					accessMiddleware, err := getMiddleware([]string{mid}, m)
+					accessMiddleware, err := getMiddleware([]string{middleware}, m)
 					if err != nil {
 						logger.Error("Error: %v", err.Error())
 					} else {
@@ -104,114 +107,12 @@ func (gatewayServer GatewayServer) Initialize() *mux.Router {
 
 					}
 					// Get route authentication middlewares if it does exist
-					rMiddleware, err := getMiddleware([]string{mid}, m)
+					routeMiddleware, err := getMiddleware([]string{middleware}, m)
 					if err != nil {
 						// Error: middlewares not found
 						logger.Error("Error: %v", err.Error())
 					} else {
-						for _, midPath := range rMiddleware.Paths {
+						attachAuthMiddlewares(route, routeMiddleware, gateway, r)
-							proxyRoute := ProxyRoute{
-								path:               route.Path,
-								rewrite:            route.Rewrite,
-								destination:        route.Destination,
-								backends:           route.Backends,
-								disableHostFording: route.DisableHostFording,
-								methods:            route.Methods,
-								cors:               route.Cors,
-								insecureSkipVerify: route.InsecureSkipVerify,
-							}
-							secureRouter := r.PathPrefix(util.ParseRoutePath(route.Path, midPath)).Subrouter()
-							//callBackRouter := r.PathPrefix(util.ParseRoutePath(route.Path, "/callback")).Subrouter()
-							//Check Authentication middlewares
-							switch rMiddleware.Type {
-							case BasicAuth:
-								basicAuth, err := getBasicAuthMiddleware(rMiddleware.Rule)
-								if err != nil {
-									logger.Error("Error: %s", err.Error())
-								} else {
-									amw := middlewares.AuthBasic{
-										Username: basicAuth.Username,
-										Password: basicAuth.Password,
-										Headers:  nil,
-										Params:   nil,
-									}
-									// Apply JWT authentication middlewares
-									secureRouter.Use(amw.AuthMiddleware)
-									secureRouter.Use(CORSHandler(route.Cors))
-									secureRouter.PathPrefix("/").Handler(proxyRoute.ProxyHandler()) // Proxy handler
-									secureRouter.PathPrefix("").Handler(proxyRoute.ProxyHandler())  // Proxy handler
-								}
-							case JWTAuth:
-								jwt, err := getJWTMiddleware(rMiddleware.Rule)
-								if err != nil {
-									logger.Error("Error: %s", err.Error())
-								} else {
-									amw := middlewares.JwtAuth{
-										AuthURL:         jwt.URL,
-										RequiredHeaders: jwt.RequiredHeaders,
-										Headers:         jwt.Headers,
-										Params:          jwt.Params,
-										Origins:         gateway.Cors.Origins,
-									}
-									// Apply JWT authentication middlewares
-									secureRouter.Use(amw.AuthMiddleware)
-									secureRouter.Use(CORSHandler(route.Cors))
-									secureRouter.PathPrefix("/").Handler(proxyRoute.ProxyHandler()) // Proxy handler
-									secureRouter.PathPrefix("").Handler(proxyRoute.ProxyHandler())  // Proxy handler
-
-								}
-							case OAuth, "openid":
-								oauth, err := oAuthMiddleware(rMiddleware.Rule)
-								if err != nil {
-									logger.Error("Error: %s", err.Error())
-								} else {
-									redirectURL := "/callback" + route.Path
-									if oauth.RedirectURL != "" {
-										redirectURL = oauth.RedirectURL
-									}
-									amw := middlewares.Oauth{
-										ClientID:     oauth.ClientID,
-										ClientSecret: oauth.ClientSecret,
-										RedirectURL:  redirectURL,
-										Scopes:       oauth.Scopes,
-										Endpoint: middlewares.OauthEndpoint{
-											AuthURL:     oauth.Endpoint.AuthURL,
-											TokenURL:    oauth.Endpoint.TokenURL,
-											UserInfoURL: oauth.Endpoint.UserInfoURL,
-										},
-										State:     oauth.State,
-										Origins:   gateway.Cors.Origins,
-										JWTSecret: oauth.JWTSecret,
-										Provider:  oauth.Provider,
-									}
-									oauthRuler := oauthRulerMiddleware(amw)
-									// Check if a cookie path is defined
-									if oauthRuler.CookiePath == "" {
-										oauthRuler.CookiePath = route.Path
-									}
-									// Check if a RedirectPath is defined
-									if oauthRuler.RedirectPath == "" {
-										oauthRuler.RedirectPath = util.ParseRoutePath(route.Path, midPath)
-									}
-									if oauthRuler.Provider == "" {
-										oauthRuler.Provider = "custom"
-									}
-									secureRouter.Use(amw.AuthMiddleware)
-									secureRouter.Use(CORSHandler(route.Cors))
-									secureRouter.PathPrefix("/").Handler(proxyRoute.ProxyHandler()) // Proxy handler
-									secureRouter.PathPrefix("").Handler(proxyRoute.ProxyHandler())  // Proxy handler
-									// Callback route
-									r.HandleFunc(util.UrlParsePath(redirectURL), oauthRuler.callbackHandler).Methods("GET")
-								}
-							default:
-								if !doesExist(rMiddleware.Type) {
-									logger.Error("Unknown middlewares type %s", rMiddleware.Type)
-								}
-
-							}
-
-						}
-
 					}
 				} else {
 					logger.Error("Error, middlewares path is empty")
@@ -242,7 +143,7 @@ func (gatewayServer GatewayServer) Initialize() *mux.Router {
 				id = util.Slug(route.Name)
 			}
 			// Apply route rate limit
-			if route.RateLimit > 0 {
+			if route.RateLimit != 0 {
 				rateLimit := middlewares.RateLimit{
 					Id:         id, // Use route index as ID
 					Requests:   route.RateLimit,
@@ -265,12 +166,12 @@ func (gatewayServer GatewayServer) Initialize() *mux.Router {
 				router.PathPrefix("").Handler(proxyRoute.ProxyHandler())
 			}
 			if gateway.EnableMetrics {
-				pr := PrometheusRoute{
+				pr := metrics.PrometheusRoute{
-					name: route.Name,
+					Name: route.Name,
-					path: route.Path,
+					Path: route.Path,
 				}
 				// Prometheus endpoint
-				router.Use(pr.prometheusMiddleware)
+				router.Use(pr.PrometheusMiddleware)
 			}
 			// Apply route Error interceptor middlewares
 			if len(route.InterceptErrors) != 0 {
@@ -299,3 +200,107 @@ func (gatewayServer GatewayServer) Initialize() *mux.Router {
 	return r
 
 }
+
+func attachAuthMiddlewares(route Route, routeMiddleware Middleware, gateway Gateway, r *mux.Router) {
+	for _, middlewarePath := range routeMiddleware.Paths {
+		proxyRoute := ProxyRoute{
+			path:               route.Path,
+			rewrite:            route.Rewrite,
+			destination:        route.Destination,
+			backends:           route.Backends,
+			disableHostFording: route.DisableHostFording,
+			methods:            route.Methods,
+			cors:               route.Cors,
+			insecureSkipVerify: route.InsecureSkipVerify,
+		}
+		secureRouter := r.PathPrefix(util.ParseRoutePath(route.Path, middlewarePath)).Subrouter()
+		// Check Authentication middleware types
+		switch routeMiddleware.Type {
+		case BasicAuth:
+			basicAuth, err := getBasicAuthMiddleware(routeMiddleware.Rule)
+			if err != nil {
+				logger.Error("Error: %s", err.Error())
+			} else {
+				authBasic := middlewares.AuthBasic{
+					Username: basicAuth.Username,
+					Password: basicAuth.Password,
+					Headers:  nil,
+					Params:   nil,
+				}
+				// Apply JWT authentication middlewares
+				secureRouter.Use(authBasic.AuthMiddleware)
+				secureRouter.Use(CORSHandler(route.Cors))
+				secureRouter.PathPrefix("/").Handler(proxyRoute.ProxyHandler()) // Proxy handler
+				secureRouter.PathPrefix("").Handler(proxyRoute.ProxyHandler())  // Proxy handler
+			}
+		case JWTAuth:
+			jwt, err := getJWTMiddleware(routeMiddleware.Rule)
+			if err != nil {
+				logger.Error("Error: %s", err.Error())
+			} else {
+				jwtAuth := middlewares.JwtAuth{
+					AuthURL:         jwt.URL,
+					RequiredHeaders: jwt.RequiredHeaders,
+					Headers:         jwt.Headers,
+					Params:          jwt.Params,
+					Origins:         gateway.Cors.Origins,
+				}
+				// Apply JWT authentication middlewares
+				secureRouter.Use(jwtAuth.AuthMiddleware)
+				secureRouter.Use(CORSHandler(route.Cors))
+				secureRouter.PathPrefix("/").Handler(proxyRoute.ProxyHandler()) // Proxy handler
+				secureRouter.PathPrefix("").Handler(proxyRoute.ProxyHandler())  // Proxy handler
+
+			}
+		case OAuth:
+			oauth, err := oAuthMiddleware(routeMiddleware.Rule)
+			if err != nil {
+				logger.Error("Error: %s", err.Error())
+			} else {
+				redirectURL := "/callback" + route.Path
+				if oauth.RedirectURL != "" {
+					redirectURL = oauth.RedirectURL
+				}
+				amw := middlewares.Oauth{
+					ClientID:     oauth.ClientID,
+					ClientSecret: oauth.ClientSecret,
+					RedirectURL:  redirectURL,
+					Scopes:       oauth.Scopes,
+					Endpoint: middlewares.OauthEndpoint{
+						AuthURL:     oauth.Endpoint.AuthURL,
+						TokenURL:    oauth.Endpoint.TokenURL,
+						UserInfoURL: oauth.Endpoint.UserInfoURL,
+					},
+					State:     oauth.State,
+					Origins:   gateway.Cors.Origins,
+					JWTSecret: oauth.JWTSecret,
+					Provider:  oauth.Provider,
+				}
+				oauthRuler := oauthRulerMiddleware(amw)
+				// Check if a cookie path is defined
+				if oauthRuler.CookiePath == "" {
+					oauthRuler.CookiePath = route.Path
+				}
+				// Check if a RedirectPath is defined
+				if oauthRuler.RedirectPath == "" {
+					oauthRuler.RedirectPath = util.ParseRoutePath(route.Path, middlewarePath)
+				}
+				if oauthRuler.Provider == "" {
+					oauthRuler.Provider = "custom"
+				}
+				secureRouter.Use(amw.AuthMiddleware)
+				secureRouter.Use(CORSHandler(route.Cors))
+				secureRouter.PathPrefix("/").Handler(proxyRoute.ProxyHandler()) // Proxy handler
+				secureRouter.PathPrefix("").Handler(proxyRoute.ProxyHandler())  // Proxy handler
+				// Callback route
+				r.HandleFunc(util.UrlParsePath(redirectURL), oauthRuler.callbackHandler).Methods("GET")
+			}
+		default:
+			if !doesExist(routeMiddleware.Type) {
+				logger.Error("Unknown middlewares type %s", routeMiddleware.Type)
+			}
+
+		}
+
+	}
+}

internal/server.go

@@ -19,7 +19,6 @@ import (
 	"context"
 	"crypto/tls"
 	"errors"
-	"fmt"
 	"github.com/jkaninda/goma-gateway/pkg/logger"
 	"net/http"
 	"os"
@@ -33,9 +32,7 @@ func (gatewayServer GatewayServer) Start() error {
 	logger.Info("Initializing routes...")
 	route := gatewayServer.Initialize()
 	logger.Debug("Routes count=%d, Middlewares count=%d", len(gatewayServer.gateway.Routes), len(gatewayServer.middlewares))
-	if err := gatewayServer.initRedis(); err != nil {
+	gatewayServer.initRedis()
-		return fmt.Errorf("failed to initialize Redis: %w", err)
-	}
 	defer gatewayServer.closeRedis()
 
 	tlsConfig, listenWithTLS, err := gatewayServer.initTLS()
@@ -51,9 +48,7 @@ func (gatewayServer GatewayServer) Start() error {
 	httpsServer := gatewayServer.createServer(":8443", route, tlsConfig)
 
 	// Start HTTP/HTTPS servers
-	if err := gatewayServer.startServers(httpServer, httpsServer, listenWithTLS); err != nil {
+	gatewayServer.startServers(httpServer, httpsServer, listenWithTLS)
-		return err
-	}
 
 	// Handle graceful shutdown
 	return gatewayServer.shutdown(httpServer, httpsServer, listenWithTLS)
@@ -70,7 +65,7 @@ func (gatewayServer GatewayServer) createServer(addr string, handler http.Handle
 	}
 }
 
-func (gatewayServer GatewayServer) startServers(httpServer, httpsServer *http.Server, listenWithTLS bool) error {
+func (gatewayServer GatewayServer) startServers(httpServer, httpsServer *http.Server, listenWithTLS bool) {
 	go func() {
 		logger.Info("Starting HTTP server on 0.0.0.0:8080")
 		if err := httpServer.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
@@ -86,8 +81,6 @@ func (gatewayServer GatewayServer) startServers(httpServer, httpsServer *http.Se
 			}
 		}()
 	}
-
-	return nil
 }
 
 func (gatewayServer GatewayServer) shutdown(httpServer, httpsServer *http.Server, listenWithTLS bool) error {

internal/types.go

@@ -123,7 +123,6 @@ type ProxyRoute struct {
 	rewrite            string
 	destination        string
 	backends           []string
-	//healthCheck        RouteHealthCheck
 	methods            []string
 	cors               Cors
 	disableHostFording bool

pkg/logger/logger.go

@@ -55,7 +55,7 @@ func Fatal(msg string, args ...interface{}) {
 func Debug(msg string, args ...interface{}) {
 	log.SetOutput(getStd(util.GetStringEnv("GOMA_ACCESS_LOG", "/dev/stdout")))
 	logLevel := util.GetStringEnv("GOMA_LOG_LEVEL", "")
-	if strings.ToLower(logLevel) == "trace" || strings.ToLower(logLevel) == "debug" {
+	if strings.ToLower(logLevel) == traceLog || strings.ToLower(logLevel) == "debug" {
 		logWithCaller("DEBUG", msg, args...)
 	}
 
@@ -63,7 +63,7 @@ func Debug(msg string, args ...interface{}) {
 func Trace(msg string, args ...interface{}) {
 	log.SetOutput(getStd(util.GetStringEnv("GOMA_ACCESS_LOG", "/dev/stdout")))
 	logLevel := util.GetStringEnv("GOMA_LOG_LEVEL", "")
-	if strings.ToLower(logLevel) == "trace" {
+	if strings.ToLower(logLevel) == traceLog {
 		logWithCaller("DEBUG", msg, args...)
 	}
 
@@ -86,7 +86,7 @@ func logWithCaller(level, msg string, args ...interface{}) {
 	// Log message with caller information if GOMA_LOG_LEVEL is trace
 	logLevel := util.GetStringEnv("GOMA_LOG_LEVEL", "")
 	if strings.ToLower(logLevel) != "off" {
-		if strings.ToLower(logLevel) == "trace" {
+		if strings.ToLower(logLevel) == traceLog {
 			log.Printf("%s: %s (File: %s, Line: %d)\n", level, formattedMessage, file, line)
 		} else {
 			log.Printf("%s: %s\n", level, formattedMessage)

pkg/logger/var.go

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2024 Jonas Kaninda
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package logger
+
+const traceLog = "trace"

util/helpers.go

@@ -10,13 +10,14 @@ You may get a copy of the License at
     http://www.apache.org/licenses/LICENSE-2.0
 */
 import (
-	"github.com/robfig/cron/v3"
 	"net/url"
 	"os"
 	"regexp"
 	"strconv"
 	"strings"
 	"time"
+
+	"github.com/robfig/cron/v3"
 )
 
 // FileExists checks if the file does exist
@@ -87,7 +88,7 @@ func MergeSlices(slice1, slice2 []string) []string {
 	return append(slice1, slice2...)
 }
 
-// ParseURLPath returns a URL path
+// ParseURLPath removes duplicated [//]
 func ParseURLPath(urlPath string) string {
 	// Replace any double slashes with a single slash
 	urlPath = strings.ReplaceAll(urlPath, "//", "/")
@@ -148,7 +149,7 @@ func Slug(text string) string {
 	text = strings.ToLower(text)
 
 	// Replace spaces and special characters with hyphens
-	re := regexp.MustCompile(`[^\w]+`)
+	re := regexp.MustCompile(`\W+`)
 	text = re.ReplaceAllString(text, "-")
 
 	// Remove leading and trailing hyphens