added draft implementation

Author: kofoworola

apidef/oas/operation.go

@@ -29,6 +29,9 @@ type Operation struct {
 	// IgnoreAuthentication ignores authentication on request by allowance.
 	IgnoreAuthentication *Allowance `bson:"ignoreAuthentication,omitempty" json:"ignoreAuthentication,omitempty"`
 
+	// TrafficShaping contains configuration for traffic control and gradual rollouts.
+	TrafficShaping *TrafficShaping `bson:"trafficShaping,omitempty" json:"trafficShaping,omitempty"`
+
 	// Internal makes the endpoint only respond to internal requests.
 	Internal *Internal `bson:"internal,omitempty" json:"internal,omitempty"`
 

apidef/oas/traffic_shaping.go

@@ -0,0 +1,54 @@
+package oas
+
+import (
+	"github.com/TykTechnologies/tyk/apidef"
+)
+
+// TrafficShaping contains configuration for traffic control and gradual rollouts
+type TrafficShaping struct {
+	// Enabled activates the traffic shaping functionality
+	Enabled bool `bson:"enabled" json:"enabled"`
+
+	// Percentage of traffic to allow (0-100)
+	Percentage int `bson:"percentage" json:"percentage"`
+
+	// ConsistentRouting configuration
+	ConsistentRouting *ConsistentRouting `bson:"consistentRouting,omitempty" json:"consistentRouting,omitempty"`
+
+	// AlternativeEndpoint for rejected traffic
+	AlternativeEndpoint string `bson:"alternativeEndpoint,omitempty" json:"alternativeEndpoint,omitempty"`
+}
+
+// ConsistentRouting defines how to consistently route requests based on attributes
+type ConsistentRouting struct {
+	// HeaderName to extract the attribute from
+	HeaderName string `bson:"headerName" json:"headerName"`
+
+	// QueryName to extract the attribute from (optional)
+	QueryName string `bson:"queryName,omitempty" json:"queryName,omitempty"`
+}
+
+// Fill populates TrafficShaping from classic API definition
+func (t *TrafficShaping) Fill(api apidef.APIDefinition) {
+	// TODO: Implement if classic API compatibility is needed
+	t.Enabled = false
+	t.Percentage = 100
+}
+
+// ExtractTo maps TrafficShaping to classic API definition
+func (t *TrafficShaping) ExtractTo(api *apidef.APIDefinition) {
+	// TODO: Implement if classic API compatibility is needed
+}
+
+// Validate ensures the configuration is valid
+func (t *TrafficShaping) Validate() error {
+	if !t.Enabled {
+		return nil
+	}
+
+	if t.Percentage < 0 || t.Percentage > 100 {
+		return ErrInvalidPercentage
+	}
+
+	return nil
+}

gateway/model_apispec.go

@@ -1,13 +1,14 @@
 package gateway
 
 import (
-	"github.com/TykTechnologies/tyk/internal/errors"
 	"net/http"
 	"net/url"
 	"strings"
 	"sync"
 	"time"
 
+	"github.com/TykTechnologies/tyk/internal/errors"
+
 	"github.com/getkin/kin-openapi/routers"
 
 	"github.com/TykTechnologies/tyk-pump/analytics"
@@ -139,6 +140,14 @@ func (a *APISpec) injectIntoReqContext(req *http.Request) {
 	}
 }
 
+// GetTykExtension returns the Tyk extension from the OAS definition
+func (a *APISpec) GetTykExtension() *oas.XTykAPIGateway {
+	if !a.IsOAS {
+		return nil
+	}
+	return a.OAS.GetTykExtension()
+}
+
 func (a *APISpec) findOperation(r *http.Request) *Operation {
 	middleware := a.OAS.GetTykMiddleware()
 	if middleware == nil {

gateway/mw_traffic_shaping.go

@@ -0,0 +1,98 @@
+package gateway
+
+import (
+	"errors"
+	"github.com/TykTechnologies/tyk/apidef/oas"
+	"hash/fnv"
+	"net/http"
+)
+
+var (
+	ErrTrafficShapingRejected = errors.New("request rejected by traffic shaping rules")
+)
+
+// TrafficShapingMiddleware controls traffic based on configured rules
+type TrafficShapingMiddleware struct {
+	*BaseMiddleware
+}
+
+func (t *TrafficShapingMiddleware) Name() string {
+	return "TrafficShapingMiddleware"
+}
+
+// EnabledForSpec checks if any operation has traffic shaping enabled
+func (t *TrafficShapingMiddleware) EnabledForSpec() bool {
+	if ext := t.Spec.GetTykExtension(); ext != nil && ext.Middleware != nil {
+		for _, op := range ext.Middleware.Operations {
+			if op.TrafficShaping != nil && op.TrafficShaping.Enabled {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// ProcessRequest implements the traffic shaping logic
+func (t *TrafficShapingMiddleware) ProcessRequest(w http.ResponseWriter, r *http.Request, _ interface{}) (error, int) {
+	// Find operation config for this request
+	op := t.Spec.findOperation(r)
+	if op == nil || op.TrafficShaping == nil || !op.TrafficShaping.Enabled {
+		return nil, http.StatusOK
+	}
+
+	// Get routing value based on config
+	routingKey := t.getRoutingValue(r, op.TrafficShaping.ConsistentRouting)
+
+	// Check if request should be allowed
+	if !t.isAllowed(routingKey, op.TrafficShaping.Percentage) {
+		if altEndpoint := op.TrafficShaping.AlternativeEndpoint; altEndpoint != "" {
+			http.Redirect(w, r, altEndpoint, http.StatusTemporaryRedirect)
+			return nil, http.StatusTemporaryRedirect
+		}
+		return ErrTrafficShapingRejected, http.StatusTooManyRequests
+	}
+
+	return nil, http.StatusOK
+}
+
+// getRoutingValue extracts a consistent routing value from the request
+func (t *TrafficShapingMiddleware) getRoutingValue(r *http.Request, routing *oas.ConsistentRouting) string {
+	if routing == nil {
+		return r.RemoteAddr // Use IP as default
+	}
+
+	// Try header first
+	if routing.HeaderName != "" {
+		if val := r.Header.Get(routing.HeaderName); val != "" {
+			return val
+		}
+	}
+
+	// Try query param
+	if routing.QueryName != "" {
+		if val := r.URL.Query().Get(routing.QueryName); val != "" {
+			return val
+		}
+	}
+
+	return r.RemoteAddr // Fallback to IP
+}
+
+// isAllowed determines if the request should be allowed through
+func (t *TrafficShapingMiddleware) isAllowed(routingKey string, percentage int) bool {
+	if percentage >= 100 {
+		return true
+	}
+	if percentage <= 0 {
+		return false
+	}
+
+	// Hash the routing key for consistent distribution
+	h := fnv.New32a()
+	h.Write([]byte(routingKey))
+	hash := h.Sum32()
+
+	// Map to 0-99 range
+	bucket := hash % 100
+	return int(bucket) < percentage
+}