feat: [#504] Route supports configure timeout

context.go

@@ -49,6 +49,11 @@ func (c *Context) WithValue(key any, value any) {
 	c.instance.Set(goravelContextKey, goravelCtx)
 }
 
+func (c *Context) WithContext(ctx context.Context) {
+	// Changing the request context to a new context
+	c.instance.Request = c.instance.Request.WithContext(ctx)
+}
+
 func (c *Context) Context() context.Context { return c }
 
 func (c *Context) Deadline() (deadline time.Time, ok bool) {

context_test.go

@@ -1,7 +1,9 @@
 package gin
 
 import (
+	"context"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 )
@@ -30,3 +32,34 @@ func TestContext(t *testing.T) {
 	assert.Equal(t, "one", ctx.Value(1))
 	assert.Equal(t, "two point two", ctx.Value(2.2))
 }
+
+func TestWithContext(t *testing.T) {
+	httpCtx := Background()
+
+	timeoutCtx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
+	defer cancel()
+
+	httpCtx.WithContext(timeoutCtx)
+
+	ctx := httpCtx.Context()
+	assert.Equal(t, timeoutCtx, ctx)
+
+	deadline, ok := ctx.Deadline()
+	assert.True(t, ok, "Deadline should be set")
+	assert.WithinDuration(t, time.Now().Add(2*time.Second), deadline, 50*time.Millisecond, "Deadline should be approximately 2 seconds from now")
+
+	select {
+	case <-ctx.Done():
+		assert.Fail(t, "context should not be done yet")
+	default:
+
+	}
+	time.Sleep(2 * time.Second)
+
+	select {
+	case <-ctx.Done():
+		assert.Equal(t, context.DeadlineExceeded, ctx.Err(), "context should be exceeded")
+	default:
+		assert.Fail(t, "context should be done after timeout")
+	}
+}

route.go

@@ -30,6 +30,7 @@ func NewRoute(config config.Config, parameters map[string]any) (*Route, error) {
 	engine := gin.New()
 	engine.MaxMultipartMemory = int64(config.GetInt("http.drivers.gin.body_limit", 4096)) << 10
 	engine.Use(gin.Recovery()) // recovery middleware
+
 	if debugLog := getDebugLog(config); debugLog != nil {
 		engine.Use(debugLog)
 	}
@@ -77,7 +78,7 @@ func (r *Route) Fallback(handler httpcontract.HandlerFunc) {
 }
 
 func (r *Route) GlobalMiddleware(middlewares ...httpcontract.Middleware) {
-	middlewares = append(middlewares, Cors(), Tls())
+	middlewares = append(middlewares, Cors(), Tls(), TimeoutMiddleware(r.config))
 	r.instance.Use(middlewaresToGinHandlers(middlewares)...)
 	r.Router = NewGroup(
 		r.config,

route_test.go

@@ -488,6 +488,40 @@
 	}
 }
 
+func longMiddleware(_ config.Config) contractshttp.Middleware {
+	return func(ctx contractshttp.Context) {
+		time.Sleep(2 * time.Second)
+		ctx.Request().Next()
+	}
+}
+
+func TestTimeoutMiddlewareIntegration(t *testing.T) {
+	mockConfig := configmocks.NewConfig(t)
+	mockConfig.EXPECT().GetInt("http.timeout_request", 3).Return(1).Once()
+
+	mockConfig.EXPECT().GetInt("http.drivers.gin.body_limit", 4096).Return(4096).Once()
+
+	mockConfig.EXPECT().GetBool("app.debug").Return(false).Once()
+
+	route, err := NewRoute(mockConfig, nil)
+	assert.Nil(t, err)
+
+	route.GlobalMiddleware(TimeoutMiddleware(mockConfig), longMiddleware(mockConfig)
+
+	route.Get("/", func(ctx contractshttp.Context) contractshttp.Response {
+		time.Sleep(2 * time.Second)
+		return ctx.Response().String(200, "Hello, World!")
+	})
+
+	w := httptest.NewRecorder()
+	req, _ := http.NewRequest("GET", "/", nil)
+
+	route.ServeHTTP(w, req)
+
+	assert.Equal(t, http.StatusGatewayTimeout, w.Code)
+}
+
+
 type CreateUser struct {
 	Name string `form:"name" json:"name"`
 }

timeout_middleware.go

@@ -0,0 +1,32 @@
+package gin
+
+import (
+	"context"
+	"net/http"
+	"time"
+
+	contractshttp "github.com/goravel/framework/contracts/http"
+	"github.com/goravel/framework/contracts/config"
+)
+
+// TimeoutMiddleware creates middleware to set a timeout for a request
+func TimeoutMiddleware(config config.Config) contractshttp.Middleware {
+	return func(ctx contractshttp.Context) {
+		timeout := time.Duration(config.GetInt("http.timeout_request", 1)) * time.Second
+		timeoutCtx, cancel := context.WithTimeout(ctx.Context(), timeout)
+		defer cancel()
+
+		ctx.WithContext(timeoutCtx)
+
+		go ctx.Request().Next()
+
+		select {
+		case <-ctx.Request().Origin().Context().Done():
+			if timeoutCtx.Err() == context.DeadlineExceeded {
+				ctx.Response().Writer().WriteHeader(http.StatusGatewayTimeout)
+				_, _ = ctx.Response().Writer().Write([]byte("Request timed out"))
+				ctx.Request().AbortWithStatus(http.StatusGatewayTimeout)
+			}
+		}
+	}
+}