generate manifests fix

Author: salonichf5

tests/framework/generate_manifests.go

@@ -5,7 +5,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"log"
 	"text/template"
 
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
@@ -121,9 +120,14 @@ type route struct {
 
 // ScaleObjects contains objects for scale testing.
 type ScaleObjects struct {
-	// BaseObjects contains objects that are common to all scale iterations.
+	// BaseObjects contains objects that should be created first:
+	// secrets and other foundational resources.
 	BaseObjects []client.Object
-	// ScaleIterationGroups contains objects for each scale iteration.
+	// GatewayAndServiceObjects contains backend services, deployments, and Gateway objects.
+	// These are created after BaseObjects to ensure endpoints are ready before traffic.
+	GatewayAndServiceObjects []client.Object
+	// ScaleIterationGroups contains HTTPRoute objects for each scale iteration.
+	// These are applied after GatewayAndServiceObjects to start traffic flow incrementally.
 	ScaleIterationGroups [][]client.Object
 }
 
@@ -151,17 +155,16 @@ func decodeObjects(reader io.Reader) ([]client.Object, error) {
 }
 
 // GenerateScaleListenerObjects generates objects for a given number of listeners for the scale test.
-// Modified to create all services and gateways first, then scale routes.
+// Secrets are created first in BaseObjects, then backend services/deployments and Gateway in GatewayAndServiceObjects,
+// and finally HTTPRoutes in ScaleIterationGroups.
 func GenerateScaleListenerObjects(numListeners int, tls bool) (ScaleObjects, error) {
-	log.Printf("GenerateScaleListenerObjects: Starting generation for %d listeners, TLS=%v", numListeners, tls)
 	var result ScaleObjects
 
 	listeners := make([]listener, 0)
 	backends := make([]string, 0)
 	secrets := make([]string, 0)
 	routes := make([]route, 0)
 
-	// Generate all listeners, backends, and routes
 	for i := range numListeners {
 		listenerName := fmt.Sprintf("listener-%d", i)
 		hostnamePrefix := fmt.Sprintf("%d", i)
@@ -185,66 +188,44 @@ func GenerateScaleListenerObjects(numListeners int, tls bool) (ScaleObjects, err
 			HostnamePrefix: hostnamePrefix,
 			BackendName:    backendName,
 		}
-
 		routes = append(routes, r)
+
 		backends = append(backends, backendName)
 	}
 
-	log.Printf("GenerateScaleListenerObjects: Generated %d listeners, %d backends, %d secrets", len(listeners), len(backends), len(secrets))
-
-	// Generate gateway with all listeners
-	log.Printf("GenerateScaleListenerObjects: Generating gateway with %d listeners", len(listeners))
-	gatewayObjects, err := generateManifests(listeners, []route{})
+	secretObjects, err := generateSecrets(secrets)
 	if err != nil {
 		return ScaleObjects{}, err
 	}
-	log.Printf("GenerateScaleListenerObjects: Generated %d gateway objects", len(gatewayObjects))
+	result.BaseObjects = append(result.BaseObjects, secretObjects...)
 
-	// Generate secrets if TLS is enabled
-	secretObjects, err := generateSecrets(secrets)
+	backendObjects, err := generateBackendAppObjects(backends)
 	if err != nil {
 		return ScaleObjects{}, err
 	}
-	log.Printf("GenerateScaleListenerObjects: Generated %d secret objects", len(secretObjects))
+	result.GatewayAndServiceObjects = append(result.GatewayAndServiceObjects, backendObjects...)
 
-	// Generate backend app objects (services, deployments)
-	log.Printf("GenerateScaleListenerObjects: Generating backend objects for %d backends", len(backends))
-	backendObjects, err := generateBackendAppObjects(backends)
+	gatewayObjects, err := generateManifests(listeners, nil)
 	if err != nil {
 		return ScaleObjects{}, err
 	}
-	log.Printf("GenerateScaleListenerObjects: Generated %d backend objects", len(backendObjects))
-
-	// BaseObjects includes services, secrets, and gateway with all listeners
-	result.BaseObjects = append(result.BaseObjects, secretObjects...)
-	result.BaseObjects = append(result.BaseObjects, backendObjects...)
-	result.BaseObjects = append(result.BaseObjects, gatewayObjects...)
-	log.Printf("GenerateScaleListenerObjects: BaseObjects contains %d total objects", len(result.BaseObjects))
+	result.GatewayAndServiceObjects = append(result.GatewayAndServiceObjects, gatewayObjects...)
 
-	// Each iteration creates one route
-	for i := range numListeners {
-		log.Printf("GenerateScaleListenerObjects: Generating route %d: %s", i, routes[i].Name)
-		objects, err := generateManifests([]listener{}, []route{routes[i]})
-		if err != nil {
-			return ScaleObjects{}, err
-		}
-
-		result.ScaleIterationGroups = append(result.ScaleIterationGroups, objects)
-		log.Printf("GenerateScaleListenerObjects: Route %d generated %d objects", i, len(objects))
+	routeObjects, err := generateManifests(nil, routes)
+	if err != nil {
+		return ScaleObjects{}, err
 	}
+	result.ScaleIterationGroups = append(result.ScaleIterationGroups, routeObjects)
 
-	log.Printf("GenerateScaleListenerObjects: Completed. BaseObjects: %d, ScaleIterationGroups: %d", len(result.BaseObjects), len(result.ScaleIterationGroups))
 	return result, nil
 }
 
 func generateSecrets(secrets []string) ([]client.Object, error) {
-	log.Printf("generateSecrets: Generating %d secrets: %v", len(secrets), secrets)
 	objects := make([]client.Object, 0, len(secrets))
 
-	for i, secret := range secrets {
+	for _, secret := range secrets {
 		var buf bytes.Buffer
 
-		log.Printf("generateSecrets: Executing secret template for secret %d: %s", i, secret)
 		if err := secretTmpl.Execute(&buf, secret); err != nil {
 			return nil, err
 		}
@@ -254,18 +235,14 @@ func generateSecrets(secrets []string) ([]client.Object, error) {
 			return nil, err
 		}
 
-		log.Printf("generateSecrets: Secret %s generated %d objects", secret, len(objs))
 		objects = append(objects, objs...)
 	}
 
-	log.Printf("generateSecrets: Total secret objects generated: %d", len(objects))
 	return objects, nil
 }
 
 // GenerateScaleHTTPRouteObjects generates objects for a given number of routes for the scale test.
-// Modified to create all services and gateways first, then scale routes.
 func GenerateScaleHTTPRouteObjects(numRoutes int) (ScaleObjects, error) {
-	log.Printf("GenerateScaleHTTPRouteObjects: Starting generation for %d routes", numRoutes)
 	var result ScaleObjects
 
 	l := listener{
@@ -275,27 +252,21 @@ func GenerateScaleHTTPRouteObjects(numRoutes int) (ScaleObjects, error) {
 
 	backendName := "backend"
 
-	// Generate the Gateway once and add it to BaseObjects
-	log.Printf("GenerateScaleHTTPRouteObjects: Generating gateway with single listener")
-	gatewayObjects, err := generateManifests([]listener{l}, []route{})
+	// Generate backend objects and add to GatewayAndServiceObjects
+	backendObjects, err := generateBackendAppObjects([]string{backendName})
 	if err != nil {
 		return ScaleObjects{}, err
 	}
-	log.Printf("GenerateScaleHTTPRouteObjects: Generated %d gateway objects", len(gatewayObjects))
+	result.GatewayAndServiceObjects = append(result.GatewayAndServiceObjects, backendObjects...)
 
-	// Generate backend app objects (services, deployments)
-	log.Printf("GenerateScaleHTTPRouteObjects: Generating backend objects for backend: %s", backendName)
-	backendObjects, err := generateBackendAppObjects([]string{backendName})
+	// Generate Gateway object and add to GatewayAndServiceObjects
+	gatewayObjects, err := generateManifests([]listener{l}, nil)
 	if err != nil {
 		return ScaleObjects{}, err
 	}
-	log.Printf("GenerateScaleHTTPRouteObjects: Generated %d backend objects", len(backendObjects))
-
-	// BaseObjects now includes services and gateway
-	result.BaseObjects = append(backendObjects, gatewayObjects...)
-	log.Printf("GenerateScaleHTTPRouteObjects: BaseObjects contains %d total objects", len(result.BaseObjects))
+	result.GatewayAndServiceObjects = append(result.GatewayAndServiceObjects, gatewayObjects...)
 
-	// Each iteration only creates one route
+	// Generate HTTPRoute objects for each iteration
 	for i := range numRoutes {
 		r := route{
 			Name:           fmt.Sprintf("route-%d", i),
@@ -304,59 +275,46 @@ func GenerateScaleHTTPRouteObjects(numRoutes int) (ScaleObjects, error) {
 			BackendName:    backendName,
 		}
 
-		log.Printf("GenerateScaleHTTPRouteObjects: Generating route %d: %s with hostname %s", i, r.Name, r.HostnamePrefix)
-		// Generate only the route (no gateway, no listeners)
-		objects, err := generateManifests([]listener{}, []route{r})
+		// Generate only the HTTPRoute (no listeners/gateway)
+		routeObjects, err := generateManifests(nil, []route{r})
 		if err != nil {
 			return ScaleObjects{}, err
 		}
 
-		result.ScaleIterationGroups = append(result.ScaleIterationGroups, objects)
-		log.Printf("GenerateScaleHTTPRouteObjects: Route %d generated %d objects", i, len(objects))
+		result.ScaleIterationGroups = append(result.ScaleIterationGroups, routeObjects)
 	}
 
-	log.Printf("GenerateScaleHTTPRouteObjects: Completed. BaseObjects: %d, ScaleIterationGroups: %d", len(result.BaseObjects), len(result.ScaleIterationGroups))
 	return result, nil
 }
 
 func generateManifests(listeners []listener, routes []route) ([]client.Object, error) {
-	log.Printf("generateManifests: Called with %d listeners, %d routes", len(listeners), len(routes))
 	var buf bytes.Buffer
 
 	if len(listeners) > 0 {
-		log.Printf("generateManifests: Executing gateway template with %d listeners", len(listeners))
 		if err := gwTmpl.Execute(&buf, listeners); err != nil {
 			return nil, err
 		}
 	}
 
-	for i, r := range routes {
+	for _, r := range routes {
 		if buf.Len() > 0 {
 			buf.WriteString("\n---\n")
 		}
 
-		log.Printf("generateManifests: Executing route template for route %d: %s", i, r.Name)
 		if err := hrTmpl.Execute(&buf, r); err != nil {
 			return nil, err
 		}
 	}
 
-	objects, err := decodeObjects(&buf)
-	if err != nil {
-		return nil, err
-	}
-	log.Printf("generateManifests: Decoded %d objects from templates", len(objects))
-	return objects, nil
+	return decodeObjects(&buf)
 }
 
 func generateBackendAppObjects(backends []string) ([]client.Object, error) {
-	log.Printf("generateBackendAppObjects: Generating objects for %d backends: %v", len(backends), backends)
 	objects := make([]client.Object, 0, 2*len(backends))
 
-	for i, backend := range backends {
+	for _, backend := range backends {
 		var buf bytes.Buffer
 
-		log.Printf("generateBackendAppObjects: Executing app template for backend %d: %s", i, backend)
 		if err := appTmpl.Execute(&buf, backend); err != nil {
 			return nil, err
 		}
@@ -366,10 +324,8 @@ func generateBackendAppObjects(backends []string) ([]client.Object, error) {
 			return nil, err
 		}
 
-		log.Printf("generateBackendAppObjects: Backend %s generated %d objects", backend, len(objs))
 		objects = append(objects, objs...)
 	}
 
-	log.Printf("generateBackendAppObjects: Total objects generated: %d", len(objects))
 	return objects, nil
 }

tests/framework/results.go

@@ -21,6 +21,12 @@ func CreateResultsDir(testName, version string) (string, error) {
 
 	dirName := filepath.Join(filepath.Dir(pwd), "results", testName, version)
 
+	if _, err := os.Stat(dirName); err == nil {
+		if err := os.RemoveAll(dirName); err != nil {
+			return "", fmt.Errorf("failed to remove existing directory %s: %w", dirName, err)
+		}
+	}
+
 	return dirName, os.MkdirAll(dirName, 0o777)
 }