Merge branch 'main' into pre-post-merge

Author: adimoft

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 --queryformat '%{NAME}\\n'"
+	cmd := "rpm -qa"
 	if pkgType == "deb" {
 		cmd = "dpkg -l | awk '/^ii/ {print $2}'"
 		sBomFNm = debutils.GenerateSPDXFileName(template.GetImageName())
@@ -1637,20 +1637,25 @@ 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 {
-		// For DEB packages, remove architecture tag (e.g., ":amd64") if present
+		// Remove architecture tag (e.g., ":amd64") if present
 		normalizedPkg := pkg
-		if pkgType == "deb" {
-			if colonIndex := strings.Index(pkg, ":"); colonIndex != -1 {
-				normalizedPkg = pkg[:colonIndex]
-			}
+		if colonIndex := strings.Index(pkg, ":"); colonIndex != -1 {
+			normalizedPkg = pkg[:colonIndex]
 		}
 		installedPkgMap[normalizedPkg] = true
 	}
 
 	var finalPkgs []ospackage.PackageInfo
 	for _, pkg := range downloadedPkgs {
-		// pkg.Name is the clean canonical package name (e.g., "SymCrypt", "bash")
-		if installedPkgMap[pkg.Name] {
+		// 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] {
 			finalPkgs = append(finalPkgs, pkg)
 		}
 	}

internal/ospackage/ospackage.go

@@ -2,7 +2,7 @@ package ospackage
 
 // PackageInfo holds everything you need to fetch + verify one artifact.
 type PackageInfo struct {
-	Name        string // e.g. "abseil-cpp"
+	Name        string // e.g. file name "abseil-cpp.rpm"
 	Type        string // e.g. "rpm", "deb", "apk"
 	Description string // e.g. "Abseil C++ Common Libraries"
 	Origin      string // e.g. "Intel", the vendor or supplier of the package
@@ -15,6 +15,7 @@ type PackageInfo struct {
 	Requires    []string // capabilities this package requires
 	RequiresVer []string // version constraints for the required capabilities
 	Files       []string // list of files in this package (rpm:files)
+	PkgName     string   // name of the package
 }
 
 // Checksum holds the algorithm and value of a checksum.

internal/ospackage/rpmutils/download.go

@@ -396,6 +396,16 @@ func DownloadPackagesComplete(pkgList []string, destDir, dotFile string, pkgSour
 	}
 	all = append(all, userpkg...)
 
+	// Adjust package names to remove any prefixes before PkgName - Azure Linux RPM repos often prefix package file names
+	for i := range all {
+		// Find where the package name starts in the full name
+		if idx := strings.Index(all[i].Name, all[i].PkgName); idx > 0 {
+			// Remove the prefix by taking substring from where PkgName starts
+			all[i].Name = all[i].Name[idx:]
+		}
+		// If PkgName is not found or is at the beginning, keep the original Name
+	}
+
 	// Match the packages in the template against all the packages
 	req, err := MatchRequested(pkgList, all)
 	if err != nil {
@@ -430,8 +440,7 @@ func DownloadPackagesComplete(pkgList []string, destDir, dotFile string, pkgSour
 		}
 	}
 
-	// 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")
+	// Extract URLs
 	urls := make([]string, len(sorted_pkgs))
 	for i, pkg := range sorted_pkgs {
 		urls[i] = pkg.URL

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", Arch: "x86_64", Version: "1.0-1"},
+				{Name: "test-package.rpm", Arch: "x86_64"},
 			},
 			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", Version: "2.3.1-2.el8", Arch: "x86_64"},
-				{Name: "acl-dev", Arch: "x86_64"}, // Should not match - different package
+				{Name: "acl-2.3.1-2.el8", Arch: "x86_64"},
+				{Name: "acl-dev", Arch: "x86_64"}, // Should not match - not a version
 			},
 			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", Version: "1.0.0", Arch: "x86_64"},
+				{Name: "package-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", 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"},
+				{Name: "package-1.0.0", Arch: "x86_64"},
+				{Name: "package-2.0.0", Arch: "x86_64"},
+				{Name: "package-1.5.0", Arch: "x86_64"},
 			},
 			expectError: false,
-			expectCount: 1, // Should pick package with version 2.0.0 (exact name match, first found)
+			expectCount: 1, // Should pick package-2.0.0 (highest lex sort)
 		},
 	}
 
@@ -240,6 +240,136 @@ 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, candidates[0].Name)
+		op, ver, hasVersionConstraint = extractVersionRequirement(parentPkg.RequiresVer, extractBasePackageNameFromFile(candidates[0].Name))
 	}
 
 	if hasVersionConstraint {
@@ -207,6 +207,42 @@ 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 {
@@ -232,8 +268,9 @@ func findAllCandidates(parent ospackage.PackageInfo, depName string, all []ospac
 
 	// First pass: look for exact name (canonical name) matches
 	for _, pi := range all {
-		// pi.Name is already the clean package name from XML <name> element
-		if pi.Name == depName {
+		// Extract the base package name (everything before the first '-' that starts a version)
+		baseName := extractBasePackageNameFromFile(pi.Name)
+		if baseName == depName {
 			candidates = append(candidates, pi)
 		}
 	}
@@ -272,22 +309,29 @@ 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 match (e.g., "acct")
+		// 1) exact name, e.g. acct-205-25.azl3.noarch.rpm
 		if pi.Name == want {
 			candidates = append(candidates, pi)
-			exactMatch = true
+			break
+		}
+		cleanName := extractBasePackageNameFromFile(pi.Name)
+		// 2) base name, e.g. acct
+		if cleanName == want {
+			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
+		// 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
+				}
 			}
 		}
 	}
@@ -296,8 +340,8 @@ func ResolveTopPackageConflicts(want string, all []ospackage.PackageInfo) (ospac
 		return ospackage.PackageInfo{}, false
 	}
 
-	// Single candidate - return directly
-	if len(candidates) == 1 {
+	// 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) {
 		return candidates[0], true
 	}