[cudacompat] update version comparision to account for leading zeros in version strings

Any version string passed as an argument to semver.Compare() must be a valid semantic
version. It is common for NVIDIA driver versions to have leading zeros in the MINOR or
PATCH portion of a version string, e.g. 575.57.08. As a result, a call to
semver.Compare("575.57.08", "575.10.10") would incorrectly return -1 because the first
argument is not a valid semantic version.

And from https://pkg.go.dev/golang.org/x/mod/semver#Compare:

'''
An invalid semantic version string is considered less than a valid one.
All invalid semantic version strings compare equal to each other.
'''

Signed-off-by: Christopher Desiniotis <cdesiniotis@nvidia.com>

Author: cdesiniotis

cmd/nvidia-cdi-hook/cudacompat/cuda-elf-header.go

@@ -143,7 +143,7 @@ func (h *compatElfHeader) UseCompat(compatDriverVersion string, hostDriverVersio
 		return false
 	}
 
-	return semver.Compare(normalizeVersion(compatDriverVersion), normalizeVersion(hostDriverVersion)) > 0
+	return compareVersions(compatDriverVersion, hostDriverVersion) > 0
 }
 
 type cudaVersion string
@@ -155,9 +155,28 @@ func (containerVersion cudaVersion) UseCompat(hostVersion string) bool {
 		return false
 	}
 
-	return semver.Compare(normalizeVersion(containerVersion), normalizeVersion(hostVersion)) > 0
+	return compareVersions(containerVersion, hostVersion) > 0
 }
 
+func compareVersions[T string | cudaVersion, O string | cudaVersion](this T, other O) int {
+	return semver.Compare(normalizeVersion(this), normalizeVersion(other))
+}
+
+// normalizeVersion converts the given version into a valid semantic version.
+// This function will always return a string in the format of vMAJOR.MINOR.PATCH
+// It accounts for version strings that have leading zeros, which is common
+// in NVIDIA driver version strings. For example, 570.211.01 will be converted to
+// v570.22.1
 func normalizeVersion[T string | cudaVersion](v T) string {
-	return "v" + strings.TrimPrefix(string(v), "v")
+	majorMinorPatch := []string{"0", "0", "0"}
+	versionParts := strings.SplitN(strings.TrimPrefix(string(v), "v"), ".", 3)
+	for i, versionPart := range versionParts {
+		trimmed := strings.TrimLeft(versionPart, "0")
+		if trimmed == "" {
+			trimmed = "0"
+		}
+		majorMinorPatch[i] = trimmed
+	}
+
+	return "v" + strings.Join(majorMinorPatch, ".")
 }

cmd/nvidia-cdi-hook/cudacompat/cuda-elf-header_test.go

@@ -183,3 +183,93 @@ func TestUseCompat(t *testing.T) {
 		})
 	}
 }
+
+func TestCompareVersions(t *testing.T) {
+	testCases := []struct {
+		description string
+		a           string
+		b           string
+		expected    int
+	}{
+		{
+			description: "empty",
+			expected:    0,
+		},
+		{
+			description: "less than",
+			a:           "1.2.3",
+			b:           "2.4.5",
+			expected:    -1,
+		},
+		{
+			description: "equal",
+			a:           "1.1.1",
+			b:           "1.1.1",
+			expected:    0,
+		},
+		{
+			description: "equal with leading zeros in version string",
+			a:           "1.1.1",
+			b:           "1.01.1",
+			expected:    0,
+		},
+		{
+			description: "greater than",
+			a:           "2.4.5",
+			b:           "2.4.4",
+			expected:    1,
+		},
+	}
+	for _, tc := range testCases {
+		t.Run(tc.description, func(t *testing.T) {
+			require.EqualValues(t, tc.expected, compareVersions(tc.a, tc.b))
+		})
+	}
+
+}
+
+func TestNormalizeVersion(t *testing.T) {
+	testCases := []struct {
+		description string
+		input       string
+		expected    string
+	}{
+		{
+			description: "empty",
+			input:       "",
+			expected:    "v0.0.0",
+		},
+		{
+			description: "major is 0",
+			input:       "v0.1.2",
+			expected:    "v0.1.2",
+		},
+		{
+			description: "major only",
+			input:       "1",
+			expected:    "v1.0.0",
+		},
+		{
+			description: "major and minor only",
+			input:       "1.1",
+			expected:    "v1.1.0",
+		},
+		{
+			description: "zero-padded version",
+			input:       "01.02.03",
+			expected:    "v1.2.3",
+		},
+		{
+			description: "valid semantic version",
+			input:       "v1.2.3-4+567",
+			expected:    "v1.2.3-4+567",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.description, func(t *testing.T) {
+			output := normalizeVersion(tc.input)
+			require.EqualValues(t, tc.expected, output)
+		})
+	}
+}