refactor(kubevirt): Extract helper functions from create

Decompose the create function into smaller, focused helper functions:
- parseCreateParameters: Parses and validates input parameters into a struct
- matchDataSource: Matches workload input against available DataSources
- resolvePreference: Resolves preference from DataSource defaults or cluster resources
- resolveInstancetype: Resolves instancetype from DataSource defaults or size/performance hints
- matchInstancetypeBySize: Matches instancetype based on size and performance criteria
- filterInstancetypesBySize: Filters instancetypes by size hint
- buildTemplateParams: Constructs vmParams from resolved resources
- renderTemplate: Renders the VM creation plan template

This refactoring improves code organization and readability by:
- Following the single responsibility principle
- Making the main create function a clear orchestrator
- Reducing complexity and improving testability
- Enhancing maintainability through focused, reusable functions

Assisted-By: Claude <noreply@anthropic.com>
Signed-off-by: Lee Yarwood <lyarwood@redhat.com>

Author: lyarwood

pkg/toolsets/kubevirt/vm/create/tool.go

@@ -108,173 +108,235 @@ type InstancetypeInfo struct {
 }
 
 func create(params api.ToolHandlerParams) (*api.ToolCallResult, error) {
-	// Parse required parameters
-	namespace, err := getRequiredString(params, "namespace")
+	// Parse and validate input parameters
+	createParams, err := parseCreateParameters(params)
 	if err != nil {
 		return api.NewToolCallResult("", err), nil
 	}
 
-	name, err := getRequiredString(params, "name")
+	// Search for available DataSources
+	dataSources, _ := searchDataSources(params, createParams.Workload)
+
+	// Match DataSource based on workload input
+	matchedDataSource := matchDataSource(dataSources, createParams.Workload)
+
+	// Resolve preference from DataSource defaults or cluster resources
+	preference := resolvePreference(params, createParams.Preference, matchedDataSource, createParams.Workload)
+
+	// Resolve instancetype from DataSource defaults or size/performance hints
+	instancetype := resolveInstancetype(params, createParams, matchedDataSource)
+
+	// Build template parameters from resolved resources
+	templateParams := buildTemplateParams(createParams, matchedDataSource, instancetype, preference)
+
+	// Render the VM creation plan template
+	result, err := renderTemplate(templateParams)
 	if err != nil {
 		return api.NewToolCallResult("", err), nil
 	}
 
-	// Parse optional parameters
-	osInput := getOptionalString(params, "workload")
-	if osInput == "" {
-		osInput = "fedora" // Default to fedora if not specified
-	}
-	instancetype := getOptionalString(params, "instancetype")
-	preference := getOptionalString(params, "preference")
-	size := getOptionalString(params, "size")
-	performance := getOptionalString(params, "performance")
+	return api.NewToolCallResult(result, nil), nil
+}
+
+// createParameters holds parsed input parameters for VM creation
+type createParameters struct {
+	Namespace   string
+	Name        string
+	Workload    string
+	Instancetype string
+	Preference  string
+	Size        string
+	Performance string
+}
 
-	// Normalize performance parameter to instance type prefix
-	performance = normalizePerformance(performance)
+// parseCreateParameters parses and validates input parameters
+func parseCreateParameters(params api.ToolHandlerParams) (*createParameters, error) {
+	namespace, err := getRequiredString(params, "namespace")
+	if err != nil {
+		return nil, err
+	}
 
-	// Search for DataSources in the cluster
-	dataSources, err := searchDataSources(params, osInput)
+	name, err := getRequiredString(params, "name")
 	if err != nil {
-		// Don't fail completely, continue without DataSources
-		dataSources = []DataSourceInfo{}
+		return nil, err
 	}
 
-	// Check if the operating_system input matches any DataSource
-	normalizedInput := strings.ToLower(strings.TrimSpace(osInput))
-	var matchedDataSource *DataSourceInfo
+	workload := getOptionalString(params, "workload")
+	if workload == "" {
+		workload = "fedora" // Default to fedora if not specified
+	}
+
+	performance := normalizePerformance(getOptionalString(params, "performance"))
+
+	return &createParameters{
+		Namespace:    namespace,
+		Name:         name,
+		Workload:     workload,
+		Instancetype: getOptionalString(params, "instancetype"),
+		Preference:   getOptionalString(params, "preference"),
+		Size:         getOptionalString(params, "size"),
+		Performance:  performance,
+	}, nil
+}
+
+// matchDataSource finds a DataSource that matches the workload input
+func matchDataSource(dataSources []DataSourceInfo, workload string) *DataSourceInfo {
+	normalizedInput := strings.ToLower(strings.TrimSpace(workload))
 
 	// First try exact match
 	for i := range dataSources {
 		ds := &dataSources[i]
-		if strings.EqualFold(ds.Name, normalizedInput) || strings.EqualFold(ds.Name, osInput) {
-			matchedDataSource = ds
-			break
+		if strings.EqualFold(ds.Name, normalizedInput) || strings.EqualFold(ds.Name, workload) {
+			return ds
 		}
 	}
 
 	// If no exact match, try partial matching (e.g., "rhel" matches "rhel9")
 	// Only match against real DataSources with namespaces, not built-in containerdisks
-	if matchedDataSource == nil {
-		for i := range dataSources {
-			ds := &dataSources[i]
-			// Only do partial matching for real DataSources (those with namespaces)
-			if ds.Namespace != "" && strings.Contains(strings.ToLower(ds.Name), normalizedInput) {
-				matchedDataSource = ds
-				break
-			}
+	for i := range dataSources {
+		ds := &dataSources[i]
+		// Only do partial matching for real DataSources (those with namespaces)
+		if ds.Namespace != "" && strings.Contains(strings.ToLower(ds.Name), normalizedInput) {
+			return ds
 		}
 	}
 
-	// Use DataSource default preference if available and preference not specified
-	if preference == "" && matchedDataSource != nil && matchedDataSource.DefaultPreference != "" {
-		preference = matchedDataSource.DefaultPreference
+	return nil
+}
+
+// resolvePreference determines the preference to use from DataSource defaults or cluster resources
+func resolvePreference(params api.ToolHandlerParams, explicitPreference string, matchedDataSource *DataSourceInfo, workload string) string {
+	// Use explicitly specified preference if provided
+	if explicitPreference != "" {
+		return explicitPreference
 	}
 
-	// Check if the operating_system input matches any Preference when preference is not provided
-	if preference == "" {
-		preferences := searchPreferences(params)
-		for i := range preferences {
-			pref := &preferences[i]
-			// Try to match preference name against the OS input
-			// Common patterns: "fedora", "rhel.9", "ubuntu", etc.
-			if strings.Contains(strings.ToLower(pref.Name), normalizedInput) {
-				preference = pref.Name
-				break
-			}
+	// Use DataSource default preference if available
+	if matchedDataSource != nil && matchedDataSource.DefaultPreference != "" {
+		return matchedDataSource.DefaultPreference
+	}
+
+	// Try to match preference name against the workload input
+	preferences := searchPreferences(params)
+	normalizedInput := strings.ToLower(strings.TrimSpace(workload))
+
+	for i := range preferences {
+		pref := &preferences[i]
+		// Common patterns: "fedora", "rhel.9", "ubuntu", etc.
+		if strings.Contains(strings.ToLower(pref.Name), normalizedInput) {
+			return pref.Name
 		}
 	}
 
-	// Use DataSource default instancetype if available and instancetype not specified and size not specified
-	if instancetype == "" && size == "" && matchedDataSource != nil && matchedDataSource.DefaultInstancetype != "" {
-		instancetype = matchedDataSource.DefaultInstancetype
+	return ""
+}
+
+// resolveInstancetype determines the instancetype to use from DataSource defaults or size/performance hints
+func resolveInstancetype(params api.ToolHandlerParams, createParams *createParameters, matchedDataSource *DataSourceInfo) string {
+	// Use explicitly specified instancetype if provided
+	if createParams.Instancetype != "" {
+		return createParams.Instancetype
+	}
+
+	// Use DataSource default instancetype if available (when size not specified)
+	if createParams.Size == "" && matchedDataSource != nil && matchedDataSource.DefaultInstancetype != "" {
+		return matchedDataSource.DefaultInstancetype
 	}
 
-	// Check if the size parameter matches any instance type when instancetype is not provided
-	if instancetype == "" && size != "" {
-		instancetypes := searchInstancetypes(params)
-		normalizedSize := strings.ToLower(strings.TrimSpace(size))
-		normalizedPerformance := strings.ToLower(strings.TrimSpace(performance))
+	// Match instancetype based on size and performance hints
+	if createParams.Size != "" {
+		return matchInstancetypeBySize(params, createParams.Size, createParams.Performance)
+	}
 
-		// First, filter instance types by size
-		var candidatesBySize []InstancetypeInfo
-		for i := range instancetypes {
-			it := &instancetypes[i]
-			// Match instance types that contain the size hint in their name
-			if strings.Contains(strings.ToLower(it.Name), normalizedSize) {
-				candidatesBySize = append(candidatesBySize, *it)
-			}
-		}
+	return ""
+}
 
-		// Then, filter by performance family
-		// Try exact match first (e.g., "u1.small")
-		for i := range candidatesBySize {
-			it := &candidatesBySize[i]
-			// Check if instance type name starts with the performance family
-			if strings.HasPrefix(strings.ToLower(it.Name), normalizedPerformance+".") {
-				instancetype = it.Name
-				break
-			}
+// matchInstancetypeBySize finds an instancetype that matches the size and performance hints
+func matchInstancetypeBySize(params api.ToolHandlerParams, size, performance string) string {
+	instancetypes := searchInstancetypes(params)
+	normalizedSize := strings.ToLower(strings.TrimSpace(size))
+	normalizedPerformance := strings.ToLower(strings.TrimSpace(performance))
+
+	// Filter instance types by size
+	candidatesBySize := filterInstancetypesBySize(instancetypes, normalizedSize)
+	if len(candidatesBySize) == 0 {
+		return ""
+	}
+
+	// Try to match by performance family prefix (e.g., "u1.small")
+	for i := range candidatesBySize {
+		it := &candidatesBySize[i]
+		if strings.HasPrefix(strings.ToLower(it.Name), normalizedPerformance+".") {
+			return it.Name
 		}
+	}
 
-		// If no exact match, check labels for performance characteristics
-		if instancetype == "" {
-			for i := range candidatesBySize {
-				it := &candidatesBySize[i]
-				// Check labels for performance family indicators
-				if it.Labels != nil {
-					// Check common label patterns
-					if class, ok := it.Labels["instancetype.kubevirt.io/class"]; ok {
-						if strings.EqualFold(class, normalizedPerformance) {
-							instancetype = it.Name
-							break
-						}
-					}
+	// Try to match by performance family label
+	for i := range candidatesBySize {
+		it := &candidatesBySize[i]
+		if it.Labels != nil {
+			if class, ok := it.Labels["instancetype.kubevirt.io/class"]; ok {
+				if strings.EqualFold(class, normalizedPerformance) {
+					return it.Name
 				}
 			}
 		}
+	}
 
-		// If still no match, fall back to first candidate that matches size
-		if instancetype == "" && len(candidatesBySize) > 0 {
-			instancetype = candidatesBySize[0].Name
+	// Fall back to first candidate that matches size
+	return candidatesBySize[0].Name
+}
+
+// filterInstancetypesBySize filters instancetypes that contain the size hint in their name
+func filterInstancetypesBySize(instancetypes []InstancetypeInfo, normalizedSize string) []InstancetypeInfo {
+	var candidates []InstancetypeInfo
+	for i := range instancetypes {
+		it := &instancetypes[i]
+		if strings.Contains(strings.ToLower(it.Name), normalizedSize) {
+			candidates = append(candidates, *it)
 		}
 	}
+	return candidates
+}
 
-	// Prepare template parameters
-	templateParams := vmParams{
-		Namespace:    namespace,
-		Name:         name,
+// buildTemplateParams constructs the template parameters for VM creation
+func buildTemplateParams(createParams *createParameters, matchedDataSource *DataSourceInfo, instancetype, preference string) vmParams {
+	params := vmParams{
+		Namespace:    createParams.Namespace,
+		Name:         createParams.Name,
 		Instancetype: instancetype,
 		Preference:   preference,
 	}
 
 	if matchedDataSource != nil && matchedDataSource.Namespace != "" {
 		// Use the matched DataSource (real cluster DataSource with namespace)
-		templateParams.UseDataSource = true
-		templateParams.DataSourceName = matchedDataSource.Name
-		templateParams.DataSourceNamespace = matchedDataSource.Namespace
-		templateParams.ContainerDisk = "" // Not using container disk
+		params.UseDataSource = true
+		params.DataSourceName = matchedDataSource.Name
+		params.DataSourceNamespace = matchedDataSource.Namespace
 	} else if matchedDataSource != nil {
 		// Matched a built-in containerdisk (no namespace)
-		templateParams.UseDataSource = false
-		templateParams.ContainerDisk = matchedDataSource.Source
+		params.ContainerDisk = matchedDataSource.Source
 	} else {
-		// No match, resolve container disk image from OS name
-		templateParams.UseDataSource = false
-		templateParams.ContainerDisk = resolveContainerDisk(osInput)
+		// No match, resolve container disk image from workload name
+		params.ContainerDisk = resolveContainerDisk(createParams.Workload)
 	}
 
-	// Render template
+	return params
+}
+
+// renderTemplate renders the VM creation plan template
+func renderTemplate(templateParams vmParams) (string, error) {
 	tmpl, err := template.New("vm").Parse(planTemplate)
 	if err != nil {
-		return api.NewToolCallResult("", fmt.Errorf("failed to parse template: %w", err)), nil
+		return "", fmt.Errorf("failed to parse template: %w", err)
 	}
 
 	var result strings.Builder
 	if err := tmpl.Execute(&result, templateParams); err != nil {
-		return api.NewToolCallResult("", fmt.Errorf("failed to render template: %w", err)), nil
+		return "", fmt.Errorf("failed to render template: %w", err)
 	}
 
-	return api.NewToolCallResult(result.String(), nil), nil
+	return result.String(), nil
 }
 
 // Helper functions