add grpc entropy

Author: sarthyparty

conformance/tests/weight-distribution.go

@@ -75,7 +75,11 @@ type GRPCRequestSender struct {
 }
 
 func (s *GRPCRequestSender) SendRequest() (string, error) {
-	resp, err := s.client.SendRPC(s.t, s.gwAddr, s.expected, s.timeout)
+	uniqueExpected := s.expected
+	if err := grpc.AddEntropy(&uniqueExpected); err != nil {
+		return "", fmt.Errorf("error adding entropy: %w", err)
+	}
+	resp, err := s.client.SendRPC(s.t, s.gwAddr, uniqueExpected, s.timeout)
 	if err != nil {
 		return "", fmt.Errorf("failed to send gRPC request: %w", err)
 	}

conformance/utils/entropy/entropy.go

@@ -0,0 +1,85 @@
+/*
+Copyright 2025 The Kubernetes Authors.
+
+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 entropy
+
+import (
+	"crypto/rand"
+	"fmt"
+	"math/big"
+	"time"
+)
+
+// randomNumber generates a random number between 0 and limit-1
+func randomNumber(limit int64) (*int64, error) {
+	number, err := rand.Int(rand.Reader, big.NewInt(limit))
+	if err != nil {
+		return nil, err
+	}
+	n := number.Int64()
+	return &n, nil
+}
+
+// AddDelay adds a random delay up to the specified limit in milliseconds
+func AddDelay(limit int64) error {
+	randomSleepDuration, err := randomNumber(limit)
+	if err != nil {
+		return err
+	}
+	time.Sleep(time.Duration(*randomSleepDuration) * time.Millisecond)
+	return nil
+}
+
+// GenerateRandomValue generates a random value as a string for use in headers/metadata
+func GenerateRandomValue(limit int64) (string, error) {
+	randomVal, err := randomNumber(limit)
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%d", *randomVal), nil
+}
+
+// AddRandomEntropy randomly chooses to add delay, random value, or both
+// The addRandomValue function should be provided by the caller to handle
+// protocol-specific ways of adding the random value (HTTP headers, gRPC metadata, etc.)
+func AddRandomEntropy(addRandomValue func(string) error) error {
+	random, err := randomNumber(3)
+	if err != nil {
+		return err
+	}
+
+	switch *random {
+	case 0:
+		return AddDelay(1000)
+	case 1:
+		randomValue, err := GenerateRandomValue(10000)
+		if err != nil {
+			return err
+		}
+		return addRandomValue(randomValue)
+	case 2:
+		if err := AddDelay(1000); err != nil {
+			return err
+		}
+		randomValue, err := GenerateRandomValue(10000)
+		if err != nil {
+			return err
+		}
+		return addRandomValue(randomValue)
+	default:
+		return fmt.Errorf("invalid random value: %d", *random)
+	}
+}

conformance/utils/grpc/grpc.go

@@ -33,6 +33,7 @@ import (
 
 	pb "sigs.k8s.io/gateway-api/conformance/echo-basic/grpcechoserver"
 	"sigs.k8s.io/gateway-api/conformance/utils/config"
+	"sigs.k8s.io/gateway-api/conformance/utils/entropy"
 	"sigs.k8s.io/gateway-api/conformance/utils/http"
 	"sigs.k8s.io/gateway-api/conformance/utils/tlog"
 )
@@ -289,3 +290,20 @@ func MakeRequestAndExpectEventuallyConsistentResponse(t *testing.T, c Client, ti
 	http.AwaitConvergence(t, timeoutConfig.RequiredConsecutiveSuccesses, timeoutConfig.MaxTimeToConsistency, sendRPC)
 	tlog.Logf(t, "Request passed")
 }
+
+// AddEntropy adds randomness to ExpectedResponse to avoid caching issues and ensure each request is unique.
+// It randomly chooses to add a delay, random metadata, or both.
+func AddEntropy(exp *ExpectedResponse) error {
+	addRandomMetadata := func(randomValue string) error {
+		if exp.RequestMetadata == nil {
+			exp.RequestMetadata = &RequestMetadata{}
+		}
+		if exp.RequestMetadata.Metadata == nil {
+			exp.RequestMetadata.Metadata = make(map[string]string)
+		}
+		exp.RequestMetadata.Metadata["x-jitter"] = randomValue
+		return nil
+	}
+
+	return entropy.AddRandomEntropy(addRandomMetadata)
+}

conformance/utils/http/http.go

@@ -17,16 +17,15 @@ limitations under the License.
 package http
 
 import (
-	"crypto/rand"
 	"fmt"
-	"math/big"
 	"net"
 	"net/url"
 	"strings"
 	"testing"
 	"time"
 
 	"sigs.k8s.io/gateway-api/conformance/utils/config"
+	"sigs.k8s.io/gateway-api/conformance/utils/entropy"
 	"sigs.k8s.io/gateway-api/conformance/utils/roundtripper"
 	"sigs.k8s.io/gateway-api/conformance/utils/tlog"
 )
@@ -483,51 +482,11 @@ func setRedirectRequestDefaults(req *roundtripper.Request, cRes *roundtripper.Ca
 
 // addEntropy adds jitter to the request by adding either a delay up to 1 second, or a random header value, or both.
 func AddEntropy(exp *ExpectedResponse) error {
-	randomNumber := func(limit int64) (*int64, error) {
-		number, err := rand.Int(rand.Reader, big.NewInt(limit))
-		if err != nil {
-			return nil, err
-		}
-		n := number.Int64()
-		return &n, nil
-	}
-
-	// adds a delay
-	delay := func(limit int64) error {
-		randomSleepDuration, err := randomNumber(limit)
-		if err != nil {
-			return err
-		}
-		time.Sleep(time.Duration(*randomSleepDuration) * time.Millisecond)
-		return nil
-	}
-	// adds random header value
-	randomHeader := func(limit int64) error {
-		randomHeaderValue, err := randomNumber(limit)
-		if err != nil {
-			return err
-		}
+	addRandomHeader := func(randomValue string) error {
 		exp.Request.Headers = make(map[string]string)
-		exp.Request.Headers["X-Jitter"] = fmt.Sprintf("%d", *randomHeaderValue)
+		exp.Request.Headers["X-Jitter"] = randomValue
 		return nil
 	}
 
-	random, err := randomNumber(3)
-	if err != nil {
-		return err
-	}
-
-	switch *random {
-	case 0:
-		return delay(1000)
-	case 1:
-		return randomHeader(10000)
-	case 2:
-		if err := delay(1000); err != nil {
-			return err
-		}
-		return randomHeader(10000)
-	default:
-		return fmt.Errorf("invalid random value: %d", *random)
-	}
+	return entropy.AddRandomEntropy(addRandomHeader)
 }