Merge branch 'main' into main

Author: elvin03

internal/image/imageos/imageos.go

@@ -1618,7 +1618,7 @@ func configUserStartupScript(installRoot string, user config.UserConfig) error {
 func (imageOs *ImageOs) generateSBOM(installRoot string, template *config.ImageTemplate) (string, error) {
 	pkgType := imageOs.chrootEnv.GetTargetOsPkgType()
 	sBomFNm := rpmutils.GenerateSPDXFileName(template.GetImageName())
-	cmd := "rpm -qa"
+	cmd := "rpm -qa --queryformat '%{NAME}\\n'"
 	if pkgType == "deb" {
 		cmd = "dpkg -l | awk '/^ii/ {print $2}'"
 		sBomFNm = debutils.GenerateSPDXFileName(template.GetImageName())
@@ -1637,25 +1637,20 @@ func (imageOs *ImageOs) generateSBOM(installRoot string, template *config.ImageT
 	// Create a map of normalized package names from installed packages for faster lookup
 	installedPkgMap := make(map[string]bool)
 	for _, pkg := range installRootPkgs {
-		// Remove architecture tag (e.g., ":amd64") if present
+		// For DEB packages, remove architecture tag (e.g., ":amd64") if present
 		normalizedPkg := pkg
-		if colonIndex := strings.Index(pkg, ":"); colonIndex != -1 {
-			normalizedPkg = pkg[:colonIndex]
+		if pkgType == "deb" {
+			if colonIndex := strings.Index(pkg, ":"); colonIndex != -1 {
+				normalizedPkg = pkg[:colonIndex]
+			}
 		}
 		installedPkgMap[normalizedPkg] = true
 	}
 
 	var finalPkgs []ospackage.PackageInfo
 	for _, pkg := range downloadedPkgs {
-		// Normalize package name by removing file extensions
-		normalizedName := pkg.Name
-		if strings.HasSuffix(normalizedName, ".rpm") {
-			normalizedName = strings.TrimSuffix(normalizedName, ".rpm")
-		} else if strings.HasSuffix(normalizedName, ".deb") {
-			normalizedName = strings.TrimSuffix(normalizedName, ".deb")
-		}
-
-		if installedPkgMap[normalizedName] {
+		// pkg.Name is the clean canonical package name (e.g., "SymCrypt", "bash")
+		if installedPkgMap[pkg.Name] {
 			finalPkgs = append(finalPkgs, pkg)
 		}
 	}

internal/ospackage/rpmutils/download.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io"
 	"os"
+	"path"
 	"path/filepath"
 	"strings"
 	"time"
@@ -429,11 +430,12 @@ func DownloadPackagesComplete(pkgList []string, destDir, dotFile string, pkgSour
 		}
 	}
 
-	// Extract URLs
+	// Extract URLs and build download list using URL basenames
+	// (files are saved by URL basename, e.g., "SymCrypt-106.0.1-1.emt3.x86_64.rpm")
 	urls := make([]string, len(sorted_pkgs))
 	for i, pkg := range sorted_pkgs {
 		urls[i] = pkg.URL
-		downloadPkgList = append(downloadPkgList, pkg.Name)
+		downloadPkgList = append(downloadPkgList, path.Base(pkg.URL))
 	}
 
 	// Ensure dest directory exists

internal/ospackage/rpmutils/download_test.go

@@ -164,7 +164,7 @@ func TestMatchRequested(t *testing.T) {
 			name:     "exact name match with .rpm extension",
 			requests: []string{"test-package"},
 			all: []ospackage.PackageInfo{
-				{Name: "test-package.rpm", Arch: "x86_64"},
+				{Name: "test-package", Arch: "x86_64", Version: "1.0-1"},
 			},
 			expectError: false,
 			expectCount: 1,
@@ -173,8 +173,8 @@ func TestMatchRequested(t *testing.T) {
 			name:     "version prefix match",
 			requests: []string{"acl"},
 			all: []ospackage.PackageInfo{
-				{Name: "acl-2.3.1-2.el8", Arch: "x86_64"},
-				{Name: "acl-dev", Arch: "x86_64"}, // Should not match - not a version
+				{Name: "acl", Version: "2.3.1-2.el8", Arch: "x86_64"},
+				{Name: "acl-dev", Arch: "x86_64"}, // Should not match - different package
 			},
 			expectError: false,
 			expectCount: 1,
@@ -183,7 +183,7 @@ func TestMatchRequested(t *testing.T) {
 			name:     "release prefix match",
 			requests: []string{"package"},
 			all: []ospackage.PackageInfo{
-				{Name: "package-1.0.0", Arch: "x86_64"},
+				{Name: "package", Version: "1.0.0", Arch: "x86_64"},
 			},
 			expectError: false,
 			expectCount: 1,
@@ -211,12 +211,12 @@ func TestMatchRequested(t *testing.T) {
 			name:     "multiple candidates - pick highest",
 			requests: []string{"package"},
 			all: []ospackage.PackageInfo{
-				{Name: "package-1.0.0", Arch: "x86_64"},
-				{Name: "package-2.0.0", Arch: "x86_64"},
-				{Name: "package-1.5.0", Arch: "x86_64"},
+				{Name: "package", Version: "1.0.0", Arch: "x86_64"},
+				{Name: "package", Version: "2.0.0", Arch: "x86_64"},
+				{Name: "package", Version: "1.5.0", Arch: "x86_64"},
 			},
 			expectError: false,
-			expectCount: 1, // Should pick package-2.0.0 (highest lex sort)
+			expectCount: 1, // Should pick package with version 2.0.0 (exact name match, first found)
 		},
 	}
 
@@ -240,136 +240,6 @@ func TestMatchRequested(t *testing.T) {
 	}
 }
 
-func TestIsAcceptedChar(t *testing.T) {
-	testCases := []struct {
-		name     string
-		input    string
-		expected bool
-	}{
-		{
-			name:     "empty string",
-			input:    "",
-			expected: false,
-		},
-		{
-			name:     "only digits",
-			input:    "123",
-			expected: true,
-		},
-		{
-			name:     "digits with dash",
-			input:    "1-2-3",
-			expected: true,
-		},
-		{
-			name:     "contains letters",
-			input:    "1a2",
-			expected: false,
-		},
-		{
-			name:     "contains special chars",
-			input:    "1.2",
-			expected: false,
-		},
-		{
-			name:     "only dash",
-			input:    "-",
-			expected: true,
-		},
-		{
-			name:     "mixed valid chars",
-			input:    "123-456-789",
-			expected: true,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			// Since isAcceptedChar is not exported, we need to test it indirectly through isValidVersionFormat
-			// or we need to make it exported for testing. For now, let's test it indirectly.
-			t.Skip("isAcceptedChar is not exported - testing indirectly through isValidVersionFormat")
-		})
-	}
-}
-
-func TestIsValidVersionFormat(t *testing.T) {
-	testCases := []struct {
-		name     string
-		input    string
-		expected bool
-	}{
-		{
-			name:     "empty string",
-			input:    "",
-			expected: false,
-		},
-		{
-			name:     "simple version",
-			input:    "1.0.0",
-			expected: true,
-		},
-		{
-			name:     "version with dash",
-			input:    "1-2.el8",
-			expected: true,
-		},
-		{
-			name:     "version without dot",
-			input:    "123",
-			expected: true,
-		},
-		{
-			name:     "invalid version with letters",
-			input:    "abc.def",
-			expected: false,
-		},
-		{
-			name:     "version starting with letter",
-			input:    "a1.0.0",
-			expected: false,
-		},
-		{
-			name:     "complex version",
-			input:    "2-3-1.el8_5",
-			expected: true,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			// Since isValidVersionFormat is not exported, we'll test it indirectly
-			// Let's create a test that exercises this through MatchRequested
-			all := []ospackage.PackageInfo{
-				{Name: fmt.Sprintf("package-%s", tc.input), Arch: "x86_64"},
-			}
-
-			result, err := rpmutils.MatchRequested([]string{"package"}, all)
-
-			if tc.expected {
-				// If the version format is valid, we should find a match
-				if err != nil || len(result) == 0 {
-					t.Errorf("Expected to find match for valid version format %q", tc.input)
-				}
-			} else {
-				// If the version format is invalid, we should not find a match (unless it's exact)
-				if err == nil && len(result) > 0 && result[0].Name != "package" {
-					// Only fail if we found a match that wasn't exact
-					exactMatch := false
-					for _, pkg := range all {
-						if pkg.Name == "package" {
-							exactMatch = true
-							break
-						}
-					}
-					if !exactMatch {
-						t.Errorf("Expected no match for invalid version format %q, but got: %v", tc.input, result)
-					}
-				}
-			}
-		})
-	}
-}
-
 func TestValidate(t *testing.T) {
 	// Save original global variables
 	originalRepoCfg := rpmutils.RepoCfg

internal/ospackage/rpmutils/helper.go

@@ -27,7 +27,7 @@ func resolveMultiCandidates(parentPkg ospackage.PackageInfo, candidates []ospack
 	ver := ""
 	hasVersionConstraint := false
 	if len(candidates) > 0 {
-		op, ver, hasVersionConstraint = extractVersionRequirement(parentPkg.RequiresVer, extractBasePackageNameFromFile(candidates[0].Name))
+		op, ver, hasVersionConstraint = extractVersionRequirement(parentPkg.RequiresVer, candidates[0].Name)
 	}
 
 	if hasVersionConstraint {
@@ -207,42 +207,6 @@ func compareVersions(v1, v2 string) int {
 	return cmp
 }
 
-// extractBasePackageNameFromFile extracts the base package name from a full package filename
-// e.g., "curl-8.8.0-2.azl3.x86_64.rpm" -> "curl"
-// e.g., "curl-devel-8.8.0-1.azl3.x86_64.rpm" -> "curl-devel"
-func extractBasePackageNameFromFile(fullName string) string {
-	// Remove .rpm suffix if present
-	name := strings.TrimSuffix(fullName, ".rpm")
-
-	// Split by '-' and find where the version starts
-	parts := strings.Split(name, "-")
-	if len(parts) < 2 {
-		return name
-	}
-
-	// Find the first part that looks like a version (starts with digit)
-	for i := 1; i < len(parts); i++ {
-		if len(parts[i]) > 0 && (parts[i][0] >= '0' && parts[i][0] <= '9') {
-			// get the name
-			maybe_name := strings.Join(parts[:i], "-")
-			// check if version is part of the name
-			// full name contains version, if package name has version,
-			// it will be repeated in the full name
-			for j := i + 1; j < len(parts); j++ {
-				if len(parts[j]) > 0 && strings.Contains(parts[j], parts[i]) {
-					maybe_name = strings.Join(parts[:j], "-")
-					break
-				}
-			}
-			// return name or name-version
-			return maybe_name
-		}
-	}
-
-	// If no version-like part found, return the whole name
-	return name
-}
-
 // extractBaseNameFromDep takes a potentially complex requirement string
 // and returns only the base package/capability name.
 func extractBaseNameFromDep(req string) string {
@@ -268,9 +232,8 @@ func findAllCandidates(parent ospackage.PackageInfo, depName string, all []ospac
 
 	// First pass: look for exact name (canonical name) matches
 	for _, pi := range all {
-		// Extract the base package name (everything before the first '-' that starts a version)
-		baseName := extractBasePackageNameFromFile(pi.Name)
-		if baseName == depName {
+		// pi.Name is already the clean package name from XML <name> element
+		if pi.Name == depName {
 			candidates = append(candidates, pi)
 		}
 	}
@@ -309,29 +272,22 @@ func findAllCandidates(parent ospackage.PackageInfo, depName string, all []ospac
 // ResolvePackage finds the best matching package for a given package name
 func ResolveTopPackageConflicts(want string, all []ospackage.PackageInfo) (ospackage.PackageInfo, bool) {
 	var candidates []ospackage.PackageInfo
+	exactMatch := false
 	for _, pi := range all {
-		// 1) exact name, e.g. acct-205-25.azl3.noarch.rpm
+		// 1) exact name match (e.g., "acct")
 		if pi.Name == want {
 			candidates = append(candidates, pi)
-			break
-		}
-		cleanName := extractBasePackageNameFromFile(pi.Name)
-		// 2) base name, e.g. acct
-		if cleanName == want {
-			candidates = append(candidates, pi)
+			exactMatch = true
 			continue
 		}
-		// 3) prefix by want-version ("acl-")
-		// expected pi.Name should look like openvino-2025.3.0-2025.3.0.19807-1.noarch.rpm
-		// want = openvino-2025.3.0
-		if strings.HasPrefix(pi.Name, want) {
-			// Extract string after "-" and compare with pi.Version
-			if dashIdx := strings.LastIndex(want, "-"); dashIdx != -1 {
-				verStr := want[dashIdx+1:]
-				if strings.Contains(pi.Version, verStr) {
-					candidates = append(candidates, pi)
-					continue
-				}
+		// 2) prefix match for version-specific requests (e.g., want = "openvino-2025.3.0")
+		//    Only try prefix match if we haven't found any exact matches
+		if !exactMatch && strings.HasPrefix(want, pi.Name+"-") && len(want) > len(pi.Name)+1 {
+			// Extract string after package name and compare with pi.Version
+			verStr := want[len(pi.Name)+1:]
+			if strings.Contains(pi.Version, verStr) {
+				candidates = append(candidates, pi)
+				continue
 			}
 		}
 	}
@@ -340,8 +296,8 @@ func ResolveTopPackageConflicts(want string, all []ospackage.PackageInfo) (ospac
 		return ospackage.PackageInfo{}, false
 	}
 
-	// If we got an exact match in step (1), it's the only candidate
-	if len(candidates) == 1 && (candidates[0].Name == want || extractBasePackageNameFromFile(candidates[0].Name) == want) {
+	// Single candidate - return directly
+	if len(candidates) == 1 {
 		return candidates[0], true
 	}