feat: add auto route healthcheck

internal/config.go

@@ -204,8 +204,8 @@ func initConfig(configFile string) error {
 					HealthCheck: RouteHealthCheck{
 						Path:            "/health/live",
 						HealthyStatuses: []int{200, 404},
-						Interval:        30,
-						Timeout:         10,
+						Interval:        "30s",
+						Timeout:         "10s",
 					},
 				},
 			},

internal/handler.go

@@ -20,6 +20,7 @@ import (
 	"encoding/json"
 	"github.com/gorilla/mux"
 	"github.com/jkaninda/goma-gateway/pkg/logger"
+	"github.com/jkaninda/goma-gateway/util"
 	"net/http"
 	"sync"
 )
@@ -73,7 +74,13 @@ func (heathRoute HealthCheckRoute) HealthCheckHandler(w http.ResponseWriter, r *
 		go func() {
 			defer wg.Done()
 			if route.HealthCheck.Path != "" {
-				err := healthCheck(route.Destination+route.HealthCheck.Path, route.HealthCheck.HealthyStatuses)
+				timeout, _ := util.ParseDuration(route.HealthCheck.Timeout)
+				health := Health{
+					URL:             route.Destination + route.HealthCheck.Path,
+					TimeOut:         timeout,
+					HealthyStatuses: route.HealthCheck.HealthyStatuses,
+				}
+				err := health.Check()
 				if err != nil {
 					if heathRoute.DisableRouteHealthCheckError {
 						routes = append(routes, HealthCheckRouteResponse{Name: route.Name, Status: "unhealthy", Error: "Route healthcheck errors disabled"})

internal/healthCheck.go

@@ -18,14 +18,23 @@ limitations under the License.
 import (
 	"fmt"
 	"github.com/jkaninda/goma-gateway/pkg/logger"
+	"github.com/jkaninda/goma-gateway/util"
+	"github.com/robfig/cron/v3"
 	"io"
 	"net/http"
 	"net/url"
 	"slices"
+	"time"
 )
 
-func healthCheck(healthURL string, healthyStatuses []int) error {
-	healthCheckURL, err := url.Parse(healthURL)
+type Health struct {
+	URL             string
+	TimeOut         time.Duration
+	HealthyStatuses []int
+}
+
+func (health Health) Check() error {
+	healthCheckURL, err := url.Parse(health.URL)
 	if err != nil {
 		return fmt.Errorf("error parsing HealthCheck URL: %v ", err)
 	}
@@ -35,7 +44,7 @@ func healthCheck(healthURL string, healthyStatuses []int) error {
 		return fmt.Errorf("error creating HealthCheck request: %v ", err)
 	}
 	// Perform the request to the route's healthcheck
-	client := &http.Client{}
+	client := &http.Client{Timeout: health.TimeOut}
 	healthResp, err := client.Do(healthReq)
 	if err != nil {
 		logger.Error("Error performing HealthCheck request: %v ", err)
@@ -46,16 +55,94 @@ func healthCheck(healthURL string, healthyStatuses []int) error {
 		if err != nil {
 		}
 	}(healthResp.Body)
-	if len(healthyStatuses) > 0 {
-		if !slices.Contains(healthyStatuses, healthResp.StatusCode) {
-			logger.Error("Error performing HealthCheck request: %v ", err)
+	if len(health.HealthyStatuses) > 0 {
+		if !slices.Contains(health.HealthyStatuses, healthResp.StatusCode) {
+			logger.Error("Error: health check failed with status code %d", healthResp.StatusCode)
 			return fmt.Errorf("health check failed with status code %v", healthResp.StatusCode)
 		}
 	} else {
 		if healthResp.StatusCode >= 400 {
-			logger.Debug("Error performing HealthCheck request: %v ", err)
+			logger.Error("Error: health check failed with status code %d", healthResp.StatusCode)
 			return fmt.Errorf("health check failed with status code %v", healthResp.StatusCode)
 		}
 	}
 	return nil
 }
+func routesHealthCheck(routes []Route) {
+	for _, route := range routes {
+		go func() {
+			if len(route.HealthCheck.Path) > 0 {
+				interval := "30s"
+				timeout, _ := util.ParseDuration("")
+				if len(route.HealthCheck.Interval) > 0 {
+					interval = route.HealthCheck.Interval
+				}
+				expression := fmt.Sprintf("@every %s", interval)
+				if !util.IsValidCronExpression(expression) {
+					logger.Error("Health check interval is invalid: %s", interval)
+					logger.Info("Route health check ignored")
+					return
+				}
+				if len(route.HealthCheck.Timeout) > 0 {
+					d1, err1 := util.ParseDuration(route.HealthCheck.Timeout)
+					if err1 != nil {
+						logger.Error("Health check timeout is invalid: %s", route.HealthCheck.Timeout)
+						return
+					}
+					timeout = d1
+
+				}
+				if len(route.Backends) > 0 {
+					for index, backend := range route.Backends {
+						err := createCron(fmt.Sprintf("%s [%d]", route.Name, index), expression, backend+route.HealthCheck.Path, timeout, route.HealthCheck.HealthyStatuses)
+						if err != nil {
+							logger.Error("Error creating cron expression: %v ", err)
+							return
+						}
+					}
+
+				} else {
+					err := createCron(route.Name, expression, route.Destination+route.HealthCheck.Path, timeout, route.HealthCheck.HealthyStatuses)
+					if err != nil {
+						logger.Error("Error creating cron expression: %v ", err)
+						return
+					}
+				}
+
+			}
+		}()
+
+	}
+}
+func createCron(name, expression string, healthURL string, timeout time.Duration, healthyStatuses []int) error {
+	// Create a new cron instance
+	c := cron.New()
+
+	_, err := c.AddFunc(expression, func() {
+		health := Health{
+			URL:             healthURL,
+			TimeOut:         timeout,
+			HealthyStatuses: healthyStatuses,
+		}
+		err := health.Check()
+		if err != nil {
+			logger.Error("Route %s is unhealthy: error %v", name, err.Error())
+			return
+		}
+		logger.Info("Route %s is healthy", name)
+	})
+	if err != nil {
+		return err
+	}
+	// Start the cron scheduler
+	c.Start()
+	defer c.Stop()
+	select {}
+}
+
+type HealthCheck struct {
+	url             string
+	interval        string
+	timeout         string
+	healthyStatuses []int
+}

internal/proxy.go

@@ -72,12 +72,10 @@ func (proxyRoute ProxyRoute) ProxyHandler() http.HandlerFunc {
 		}
 		// Update the headers to allow for SSL redirection
 		if !proxyRoute.disableXForward {
-			r.URL.Host = targetURL.Host
 			r.URL.Scheme = targetURL.Scheme
 			r.Header.Set("X-Forwarded-Host", r.Header.Get("Host"))
 			r.Header.Set("X-Forwarded-For", getRealIP(r))
 			r.Header.Set("X-Real-IP", getRealIP(r))
-			r.Host = targetURL.Host
 		}
 		backendURL, _ := url.Parse(proxyRoute.destination)
 		if len(proxyRoute.backends) > 0 {

internal/route.go

@@ -35,6 +35,8 @@ func init() {
 func (gatewayServer GatewayServer) Initialize() *mux.Router {
 	gateway := gatewayServer.gateway
 	middlewares := gatewayServer.middlewares
+	//Routes background healthcheck
+	routesHealthCheck(gateway.Routes)
 	r := mux.NewRouter()
 	heath := HealthCheckRoute{
 		DisableRouteHealthCheckError: gateway.DisableRouteHealthCheckError,

internal/server.go

@@ -26,6 +26,7 @@ import (
 	"time"
 )
 
+// Start starts the server
 func (gatewayServer GatewayServer) Start(ctx context.Context) error {
 	logger.Info("Initializing routes...")
 	route := gatewayServer.Initialize()
@@ -64,7 +65,6 @@ func (gatewayServer GatewayServer) Start(ctx context.Context) error {
 	}
 	// Set KeepAlive
 	httpServer.SetKeepAlivesEnabled(!gatewayServer.gateway.DisableKeepAlive)
-	httpsServer.SetKeepAlivesEnabled(!gatewayServer.gateway.DisableKeepAlive)
 	go func() {
 		logger.Info("Starting HTTP server listen=0.0.0.0:8080")
 		if err := httpServer.ListenAndServe(); err != nil {

internal/types.go

@@ -208,8 +208,8 @@ type Gateway struct {
 
 type RouteHealthCheck struct {
 	Path            string `yaml:"path"`
-	Interval        int    `yaml:"interval"`
-	Timeout         int    `yaml:"timeout"`
+	Interval        string `yaml:"interval"`
+	Timeout         string `yaml:"timeout"`
 	HealthyStatuses []int  `yaml:"healthyStatuses"`
 }
 type GatewayConfig struct {

internal/var.go

@@ -11,3 +11,5 @@ const JWTAuth = "jwt"             // JWT authentication middleware
 const OAuth = "oauth"             // OAuth authentication middleware
 // Round-robin counter
 var counter uint32
+
+var routes *[]Route