[no-relnote] Refactor creation of discoverer for tegra systems

This change updates the way we construct a discoverer for tegra systems
to be more flexible in terms of how the SOURCES of the mount specs can
be specified. This allows for subsequent changes like adding (or removing)
mount specs at the point of construction.

Signed-off-by: Evan Lezar <[email protected]>

Author: elezar

internal/platform-support/tegra/csv_test.go

@@ -186,13 +186,17 @@ func TestDiscovererFromCSVFiles(t *testing.T) {
 			o := options{
 				logger:              logger,
 				hookCreator:         hookCreator,
-				ignorePatterns:      tc.ignorePatterns,
 				symlinkLocator:      tc.symlinkLocator,
 				symlinkChainLocator: tc.symlinkChainLocator,
 				resolveSymlink:      tc.symlinkResolver,
+
+				mountSpecs: Transform(
+					tc.moutSpecs,
+					IgnoreSymlinkMountSpecsByPattern(tc.ignorePatterns...),
+				),
 			}
 
-			d, err := o.newDiscovererFromMountSpecs(tc.moutSpecs)
+			d, err := o.newDiscovererFromMountSpecs(o.mountSpecs.MountSpecPathsByType())
 			require.ErrorIs(t, err, tc.expectedError)
 
 			hooks, err := d.Hooks()

internal/platform-support/tegra/filter.go

@@ -59,3 +59,89 @@ func (d ignoreSymlinkMountSpecPatterns) Apply(input MountSpecPathsByTyper) Mount
 
 	return ms
 }
+
+// A filter removes elements from an input list and returns the remaining
+// elements.
+type filter interface {
+	apply(...string) []string
+}
+
+// A stringMatcher implements the MatchString function.
+type stringMatcher interface {
+	MatchString(string) bool
+}
+
+// A matcherAsFilter is used to ensure that a string matcher can be used as a filter.
+type matcherAsFilter struct {
+	stringMatcher
+}
+
+type filterByMountSpecType map[csv.MountSpecType]filter
+
+type pathPatterns []string
+type pathPattern string
+type basenamePattern string
+
+// MatchString for a set of path patterns returns true if any of the patterns
+// matches against the input string.
+func (d pathPatterns) MatchString(input string) bool {
+	for _, pattern := range d {
+		if match := pathPattern(pattern).MatchString(input); match {
+			return true
+		}
+	}
+	return false
+}
+
+// MatchString attempts to match a path pattern to the specified input string.
+// If the pattern starts with `**/` the input is treated as a path and only
+// the basenames are matched using regular glob rules.
+func (d pathPattern) MatchString(input string) bool {
+	if strings.HasPrefix(string(d), "**/") {
+		return basenamePattern(d).MatchString(input)
+	}
+	match, _ := filepath.Match(string(d), input)
+	return match
+}
+
+// MatchString for a basename pattern applies the specified pattern against the
+// basename of the input.
+// If the pattern starts with **/, this is stripped before attempting to match.
+func (d basenamePattern) MatchString(input string) bool {
+	pattern := strings.TrimPrefix(string(d), "**/")
+	match, _ := filepath.Match(pattern, filepath.Base(input))
+	return match
+}
+
+// Apply the specified per-type filters to the input mount specs.
+func (p filterByMountSpecType) Apply(input MountSpecPathsByTyper) MountSpecPathsByTyper {
+	ms := input.MountSpecPathsByType()
+	for t, filter := range p {
+		if len(ms[t]) == 0 {
+			continue
+		}
+		ms[t] = filter.apply(ms[t]...)
+	}
+	return ms
+}
+
+// apply uses a matcher to filter an input string.
+// Each element in the input that matches is skipped and the remaining elements
+// are returned.
+func (f *matcherAsFilter) apply(input ...string) []string {
+	var filtered []string
+	for _, path := range input {
+		if f.MatchString(path) {
+			continue
+		}
+		filtered = append(filtered, path)
+	}
+	return filtered
+}
+
+// removeAll is a filter that will not return any inputs.
+type removeAll struct{}
+
+func (a removeAll) apply(...string) []string {
+	return nil
+}

internal/platform-support/tegra/filter_test.go

@@ -25,7 +25,7 @@ import (
 func TestIgnorePatterns(t *testing.T) {
 	testCases := []struct {
 		description   string
-		blockedFilter []string
+		blockedFilter pathPatterns
 		input         []string
 		expected      []string
 	}{

internal/platform-support/tegra/mount_specs.go

@@ -18,6 +18,8 @@
 package tegra
 
 import (
+	"regexp"
+
 	"github.com/NVIDIA/nvidia-container-toolkit/internal/platform-support/tegra/csv"
 )
 
@@ -80,10 +82,74 @@ type transformMountSpecByPathsByType struct {
 	input MountSpecPathsByTyper
 }
 
+type merge []MountSpecPathsByTyper
+
+// Merge combines the MountSpecPathsByType for the specified sources.
+func Merge(sources ...MountSpecPathsByTyper) MountSpecPathsByTyper {
+	return merge(sources)
+}
+
+// MountSpecPathsByType for a set of merged mount specs combines the list of
+// paths per type.
+func (ts merge) MountSpecPathsByType() MountSpecPathsByType {
+	targetsByType := make(MountSpecPathsByType)
+	for _, t := range ts {
+		if t == nil {
+			continue
+		}
+		for tType, targets := range t.MountSpecPathsByType() {
+			targetsByType[tType] = append(targetsByType[tType], targets...)
+		}
+	}
+	return targetsByType
+}
+
 func (m transformMountSpecByPathsByType) MountSpecPathsByType() MountSpecPathsByType {
 	return m.Apply(m.input).MountSpecPathsByType()
 }
 
 func IgnoreSymlinkMountSpecsByPattern(ignorePatterns ...string) Transformer {
 	return ignoreSymlinkMountSpecPatterns(ignorePatterns)
 }
+
+// OnlyDeviceNodes creates a transformer that will remove any input mounts specs
+// that are not of the `MountSpecDev` type.
+func OnlyDeviceNodes() Transformer {
+	return filterByMountSpecType{
+		csv.MountSpecDir: removeAll{},
+		csv.MountSpecLib: removeAll{},
+		csv.MountSpecSym: removeAll{},
+	}
+}
+
+// WithoutDeviceNodes creates a transformer that will remove entries with type
+// MountSpecDevice from the input.
+func WithoutDeviceNodes() Transformer {
+	return filterByMountSpecType{
+		csv.MountSpecDev: removeAll{},
+	}
+}
+
+// WithoutRegularDeviceNodes creates a transfomer which removes
+// regular `/dev/nvidia[0-9]+` device nodes from the source.
+func WithoutRegularDeviceNodes() Transformer {
+	return filterByMountSpecType{
+		csv.MountSpecDev: &matcherAsFilter{regexp.MustCompile("^/dev/nvidia[0-9]+$")},
+	}
+}
+
+// DeviceNodes creates a set of MountSpecPaths for the specified device nodes.
+// These have the MoutSpecDev type.
+func DeviceNodes(dn ...string) MountSpecPathsByTyper {
+	return MountSpecPathsByType{
+		csv.MountSpecDev: dn,
+	}
+}
+
+// DeviceNodes creates a set of MountSpecPaths for the specified symlinks.
+// These have the MountSpecSym type.
+func Symlinks(s ...string) MountSpecPathsByTyper {
+	return MountSpecPathsByType{
+		csv.MountSpecSym: s,
+	}
+}

internal/platform-support/tegra/tegra.go

@@ -56,7 +56,7 @@ func New(opts ...Option) (discover.Discover, error) {
 
 	mountSpecDiscoverer, err := o.newDiscovererFromMountSpecs(o.mountSpecs.MountSpecPathsByType())
 	if err != nil {
-		return nil, fmt.Errorf("failed to create discoverer for mount specs: %w", err)
+		return nil, fmt.Errorf("failed to create discoverer for mount specs: %v", err)
 	}
 
 	ldcacheUpdateHook, err := discover.NewLDCacheUpdateHook(o.logger, mountSpecDiscoverer, o.hookCreator, o.ldconfigPath)
@@ -75,7 +75,8 @@ func New(opts ...Option) (discover.Discover, error) {
 
 	d := discover.Merge(
 		mountSpecDiscoverer,
-		// The ldcacheUpdateHook is added last to ensure that the created symlinks are included
+		// The ldcacheUpdateHook is added after the mount spec discoverer to
+		// ensure that the symlinks are included.
 		ldcacheUpdateHook,
 		tegraSystemMounts,
 	)