added /scenarios/globals

fix globals

Author: tsebastiani

PROGRESS.md

@@ -3,7 +3,7 @@
 ## Current Status
 
 **Last updated:** 2026-01-13
-**Current phase:** REST API Enhancement - POST /scenarios/detail COMPLETED
+**Current phase:** REST API Enhancement - POST /scenarios/globals COMPLETED
 
 ### Completed
 - Project scaffolding with Kubebuilder
@@ -70,6 +70,16 @@
   - ✅ Returns detailed scenario information (title, description, input fields)
   - ✅ Returns 404 if scenario not found
   - ✅ Handler registered at POST /scenarios/detail/{scenario_name}
+- **POST /scenarios/globals/{scenario_name} endpoint completed:**
+  - ✅ Extracts scenario_name from URL path
+  - ✅ Same registry configuration pattern as /scenarios and /scenarios/detail
+  - ✅ Body is optional (registry config only)
+  - ✅ Defaults to quay.io when no body provided
+  - ✅ Calls GetGlobalEnvironment(registry, scenario_name)
+  - ✅ Returns global environment details for single scenario
+  - ✅ Returns 404 if global environment not found
+  - ✅ Type fields converted to strings (not enum integers)
+  - ✅ Handler registered at POST /scenarios/globals/{scenario_name}
 
 ### In Progress
 - None
@@ -732,6 +742,101 @@ Same as POST /scenarios - registry configuration for private registry
   - Dependencies and mutual exclusions
   - Secret field marking
 
+### Refactoring: Type Field as String ✅
+**Status:** COMPLETED
+
+**Issue:** The `Type` field in input fields was being serialized as integer (enum value) instead of string.
+
+**Solution:**
+1. Created `InputFieldResponse` and `ScenarioDetailResponse` wrapper types
+2. Convert `typing.Type` enum to string using `Type.String()` method
+3. Map all fields from krknctl models to response models
+
+**Before (incorrect):**
+```json
+{
+  "type": 0  // Integer enum value
+}
+```
+
+**After (correct):**
+```json
+{
+  "type": "string"  // Human-readable string
+}
+```
+
+**Possible type values:**
+- `"string"`, `"number"`, `"boolean"`, `"enum"`, `"file"`, `"file_base64"`
+
+### Phase 11: POST /scenarios/globals/{scenario_name} Endpoint ✅
+**Status:** COMPLETED
+
+1. ✅ Handler Implementation (internal/api/handlers.go)
+   - Implemented `PostScenarioGlobals(w, r)` handler
+   - Extracts scenario_name from URL path
+   - Request body is optional (same as /scenarios/detail)
+   - Same registry configuration pattern as other scenario endpoints
+   - Mode selection: provider.Quay (default) vs provider.Private
+   - Factory pattern: `factory.NewProviderFactory(&cfg).NewInstance(mode)`
+   - Calls `GetGlobalEnvironment(registry, scenarioName)` for single scenario
+   - Returns 404 if global environment not found
+   - Converts Type fields to strings using `field.Type.String()`
+   - Returns `ScenarioDetailResponse` directly (not a map)
+   - Comprehensive error handling (400, 404, 500)
+
+2. ✅ Route Registration (internal/api/server.go)
+   - Registered POST /scenarios/globals/{scenario_name} route
+   - Handler accessible at http://operator:8080/scenarios/globals/{scenario_name}
+
+3. ✅ Build Verification
+   - Successful compilation with no errors
+   - All dependencies resolved
+   - Binary built and ready for testing
+
+**Implementation Highlights:**
+- **Path parameter**: scenario_name in URL path (same as /scenarios/detail)
+- **Body optional**: Only for private registry configuration
+- **Default mode**: Uses quay.io when no body provided
+- **Response format**: Single ScenarioDetailResponse (not a map)
+- **Consistency**: Identical pattern to /scenarios/detail/{scenario_name}
+- **Error handling**: 404 when global environment not found
+
+**Usage Examples:**
+
+Default (quay.io):
+```bash
+curl -X POST http://localhost:8080/scenarios/globals/pod-scenarios | jq
+```
+
+With private registry:
+```bash
+curl -X POST http://localhost:8080/scenarios/globals/pod-scenarios \
+  -H "Content-Type: application/json" \
+  -d '{
+    "registryUrl": "registry.example.com",
+    "scenarioRepository": "org/krkn-scenarios"
+  }' | jq
+```
+
+**Response Example:**
+```json
+{
+  "name": "krkn",
+  "title": "Global Environment",
+  "description": "Global environment variables for krkn",
+  "fields": [
+    {
+      "name": "kubeconfig",
+      "variable": "KUBECONFIG",
+      "type": "file",
+      "required": true,
+      "mount_path": "/root/.kube/config"
+    }
+  ]
+}
+```
+
 ## Technical Notes
 
 ### KrknTargetRequest Structure
@@ -825,9 +930,10 @@ type KrknTargetRequestStatus struct {
 8. ✅ Kubernetes Service for REST API access
 9. ✅ Implement POST /scenarios endpoint with krknctl integration
 10. ✅ Implement POST /scenarios/detail/{scenario_name} endpoint
-11. Create API documentation (OpenAPI/Swagger spec)
-12. Add additional endpoints as requirements evolve
-13. Implement controller logic for KrknTargetRequest
+11. ✅ Implement POST /scenarios/globals endpoint
+12. Create API documentation (OpenAPI/Swagger spec)
+13. Add additional endpoints as requirements evolve
+14. Implement controller logic for KrknTargetRequest
 
 ## Future Work (Not in Current Scope)
 

REQUIREMENTS.md

@@ -65,8 +65,20 @@ container in the same pod.
 - - if no payload is passed it must default on quay.io
 - the purpose is to return the detail of the scenario in json format using the `GetScenarioDetail` method or 404 if not found
 
-#### refactoring ✅ COMPLETED
-- type should be returned with the string value of the enum and not with the numeric value
+### /scenarios/globals/{scenario_name} ✅ COMPLETED
+- this method must be built using the already available golang package made for krknctl to retrieve
+  the available krkn scenarios either from quay.io or from a private registry
+- the package is on the following repo https://github.com/krkn-chaos/krknctl/tree/main/pkg/provider
+- the method must instantiate the factory of the scenario providers based on the user parameters
+- - if the payload contains private registry infos `RegistryV2` provider must be instantiated
+- - if no payload is passed it must default on quay.io
+- the purpose is to return the global fields of the scenario using the `GetGlobalEnvironment` method of the provider
+- the method takes scenario_name as path parameter (same pattern as /scenarios/detail/{scenario_name})
+- the method returns 404 if global environment not found 
+
+
+#### refactoring 
+- type should be returned with the string value of the enum and not with the numeric value ✅ COMPLETED
 
 # Grpc python service requirement
 

internal/api/handlers.go

@@ -620,3 +620,148 @@ func (h *Handler) PostScenarioDetail(w http.ResponseWriter, r *http.Request) {
 
 	writeJSON(w, http.StatusOK, response)
 }
+
+// PostScenarioGlobals handles POST /scenarios/globals/{scenario_name} endpoint
+// It returns global environment fields for a specific scenario
+func (h *Handler) PostScenarioGlobals(w http.ResponseWriter, r *http.Request) {
+	// Extract scenario_name from path: /scenarios/globals/{scenario_name}
+	path := r.URL.Path
+	prefix := "/scenarios/globals/"
+
+	if len(path) <= len(prefix) {
+		writeJSONError(w, http.StatusBadRequest, ErrorResponse{
+			Error:   "bad_request",
+			Message: "scenario_name parameter is required in path",
+		})
+		return
+	}
+
+	scenarioName := path[len(prefix):]
+	if scenarioName == "" {
+		writeJSONError(w, http.StatusBadRequest, ErrorResponse{
+			Error:   "bad_request",
+			Message: "scenario_name parameter cannot be empty",
+		})
+		return
+	}
+
+	// Parse optional request body (same as /scenarios for registry config)
+	var req ScenariosRequest
+	var registry *models.RegistryV2
+	var mode provider.Mode
+
+	// Check if body is provided
+	if r.ContentLength > 0 {
+		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+			writeJSONError(w, http.StatusBadRequest, ErrorResponse{
+				Error:   "bad_request",
+				Message: "Invalid request body: " + err.Error(),
+			})
+			return
+		}
+
+		// If registry info is provided, validate and use private registry mode
+		if req.RegistryURL != "" && req.ScenarioRepository != "" {
+			registry = &models.RegistryV2{
+				Username:           req.Username,
+				Password:           req.Password,
+				Token:              req.Token,
+				RegistryURL:        req.RegistryURL,
+				ScenarioRepository: req.ScenarioRepository,
+				SkipTLS:            req.SkipTLS,
+				Insecure:           req.Insecure,
+			}
+			mode = provider.Private
+		} else if req.RegistryURL != "" || req.ScenarioRepository != "" {
+			// Partial registry info provided - error
+			writeJSONError(w, http.StatusBadRequest, ErrorResponse{
+				Error:   "bad_request",
+				Message: "Both registryUrl and scenarioRepository are required for private registry",
+			})
+			return
+		} else {
+			// Body provided but no registry info - use quay.io
+			mode = provider.Quay
+		}
+	} else {
+		// No body provided - default to quay.io
+		mode = provider.Quay
+	}
+
+	// Load krknctl config
+	cfg, err := config.LoadConfig()
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, ErrorResponse{
+			Error:   "internal_error",
+			Message: "Failed to load krknctl config: " + err.Error(),
+		})
+		return
+	}
+
+	// Create provider factory
+	providerFactory := factory.NewProviderFactory(&cfg)
+
+	// Get provider instance based on mode
+	scenarioProvider := providerFactory.NewInstance(mode)
+	if scenarioProvider == nil {
+		writeJSONError(w, http.StatusInternalServerError, ErrorResponse{
+			Error:   "internal_error",
+			Message: "Failed to create scenario provider",
+		})
+		return
+	}
+
+	// Get global environment
+	globalDetail, err := scenarioProvider.GetGlobalEnvironment(registry, scenarioName)
+	if err != nil {
+		writeJSONError(w, http.StatusInternalServerError, ErrorResponse{
+			Error:   "internal_error",
+			Message: "Failed to get global environment: " + err.Error(),
+		})
+		return
+	}
+
+	// Check if global environment was found
+	if globalDetail == nil {
+		writeJSONError(w, http.StatusNotFound, ErrorResponse{
+			Error:   "not_found",
+			Message: "Global environment for scenario '" + scenarioName + "' not found",
+		})
+		return
+	}
+
+	// Convert krknctl models.ScenarioDetail to ScenarioDetailResponse
+	// This ensures Type fields are serialized as strings instead of int64
+	var fields []InputFieldResponse
+	for _, field := range globalDetail.Fields {
+		fields = append(fields, InputFieldResponse{
+			Name:              field.Name,
+			ShortDescription:  field.ShortDescription,
+			Description:       field.Description,
+			Variable:          field.Variable,
+			Type:              field.Type.String(), // Convert enum to string
+			Default:           field.Default,
+			Validator:         field.Validator,
+			ValidationMessage: field.ValidationMessage,
+			Separator:         field.Separator,
+			AllowedValues:     field.AllowedValues,
+			Required:          field.Required,
+			MountPath:         field.MountPath,
+			Requires:          field.Requires,
+			MutuallyExcludes:  field.MutuallyExcludes,
+			Secret:            field.Secret,
+		})
+	}
+
+	response := ScenarioDetailResponse{
+		Name:         globalDetail.Name,
+		Digest:       globalDetail.Digest,
+		Size:         globalDetail.Size,
+		LastModified: globalDetail.LastModified,
+		Title:        globalDetail.Title,
+		Description:  globalDetail.Description,
+		Fields:       fields,
+	}
+
+	writeJSON(w, http.StatusOK, response)
+}

internal/api/server.go

@@ -46,6 +46,7 @@ func NewServer(port int, client client.Client, namespace string, grpcServerAddr
 	mux.HandleFunc("/targets/", handler.GetTargetByUUID)           // GET /targets/{uuid}
 	mux.HandleFunc("/scenarios", handler.PostScenarios)            // POST /scenarios
 	mux.HandleFunc("/scenarios/detail/", handler.PostScenarioDetail) // POST /scenarios/detail/{scenario_name}
+	mux.HandleFunc("/scenarios/globals/", handler.PostScenarioGlobals) // POST /scenarios/globals/{scenario_name}
 
 	// Wrap mux with logging middleware
 	server := &http.Server{

internal/api/types.go

@@ -109,3 +109,16 @@ type ScenarioDetailResponse struct {
 	Description  string               `json:"description"`
 	Fields       []InputFieldResponse `json:"fields"`
 }
+
+// GlobalsRequest represents the request body for POST /scenarios/globals
+type GlobalsRequest struct {
+	ScenariosRequest
+	// ScenarioNames is the list of scenario names to get global environments for
+	ScenarioNames []string `json:"scenarioNames"`
+}
+
+// GlobalsResponse represents the response for POST /scenarios/globals endpoint
+type GlobalsResponse struct {
+	// Globals is a map of scenario name to global environment details
+	Globals map[string]ScenarioDetailResponse `json:"globals"`
+}