invoke the actual default low-level runtime in the nvidia-ctk wrapper script

Signed-off-by: Tariq Ibrahim <[email protected]>

Author: tariq1890

cmd/nvidia-ctk-installer/toolkit/installer/executables.go

@@ -91,9 +91,10 @@ func (t *ToolkitInstaller) collectExecutables(destDir string) ([]Installer, erro
 		dotRealFilename := wrappedExecutableFilename + ".real"
 
 		w := &wrapper{
-			Source:            executablePath,
-			WrappedExecutable: dotRealFilename,
-			CheckModules:      executable.requiresKernelModule,
+			Source:                       executablePath,
+			WrappedExecutable:            dotRealFilename,
+			CheckModules:                 executable.requiresKernelModule,
+			DefaultRuntimeExecutablePath: t.defaultRuntimeExecutablePath,
 			Envvars: map[string]string{
 				"PATH": strings.Join([]string{destDir, "$PATH"}, ":"),
 			},
@@ -119,10 +120,11 @@ func (t *ToolkitInstaller) collectExecutables(destDir string) ([]Installer, erro
 }
 
 type wrapper struct {
-	Source            string
-	Envvars           map[string]string
-	WrappedExecutable string
-	CheckModules      bool
+	Source                       string
+	Envvars                      map[string]string
+	WrappedExecutable            string
+	CheckModules                 bool
+	DefaultRuntimeExecutablePath string
 }
 
 type render struct {
@@ -155,8 +157,8 @@ func (w *render) render() (io.Reader, error) {
 {{- if (.CheckModules) }}
 cat /proc/modules | grep -e "^nvidia " >/dev/null 2>&1
 if [ "${?}" != "0" ]; then
-	echo "nvidia driver modules are not yet loaded, invoking runc directly"
-	exec runc "$@"
+	echo "nvidia driver modules are not yet loaded, invoking {{ .DefaultRuntimeExecutablePath }} directly"
+	exec {{ .DefaultRuntimeExecutablePath }} "$@"
 fi
 {{- end }}
 {{- range $key, $value := .Envvars }}

cmd/nvidia-ctk-installer/toolkit/installer/executables_test.go

@@ -33,7 +33,8 @@ func TestWrapperRender(t *testing.T) {
 		{
 			description: "executable is added",
 			w: &wrapper{
-				WrappedExecutable: "some-runtime",
+				WrappedExecutable:            "some-runtime",
+				DefaultRuntimeExecutablePath: "runc",
 			},
 			expected: `#! /bin/sh
 	/dest-dir/some-runtime \
@@ -43,8 +44,9 @@ func TestWrapperRender(t *testing.T) {
 		{
 			description: "module check is added",
 			w: &wrapper{
-				WrappedExecutable: "some-runtime",
-				CheckModules:      true,
+				WrappedExecutable:            "some-runtime",
+				CheckModules:                 true,
+				DefaultRuntimeExecutablePath: "runc",
 			},
 			expected: `#! /bin/sh
 cat /proc/modules | grep -e "^nvidia " >/dev/null 2>&1
@@ -63,6 +65,7 @@ fi
 				Envvars: map[string]string{
 					"PATH": "/foo/bar/baz",
 				},
+				DefaultRuntimeExecutablePath: "runc",
 			},
 			expected: `#! /bin/sh
 PATH=/foo/bar/baz \

cmd/nvidia-ctk-installer/toolkit/installer/installer.go

@@ -41,6 +41,8 @@ type ToolkitInstaller struct {
 	artifactRoot *artifactRoot
 
 	ensureTargetDirectory Installer
+
+	defaultRuntimeExecutablePath string
 }
 
 var _ Installer = (*ToolkitInstaller)(nil)

cmd/nvidia-ctk-installer/toolkit/installer/installer_test.go

@@ -113,9 +113,10 @@ func TestToolkitInstaller(t *testing.T) {
 		},
 	}
 	i := ToolkitInstaller{
-		logger:                logger,
-		artifactRoot:          r,
-		ensureTargetDirectory: createDirectory,
+		logger:                       logger,
+		artifactRoot:                 r,
+		ensureTargetDirectory:        createDirectory,
+		defaultRuntimeExecutablePath: "runc",
 	}
 
 	err := i.Install("/foo/bar/baz")

cmd/nvidia-ctk-installer/toolkit/installer/options.go

@@ -45,3 +45,9 @@ func WithSourceRoot(sourceRoot string) Option {
 		ti.sourceRoot = sourceRoot
 	}
 }
+
+func WithDefaultRuntimeExecutablePath(path string) Option {
+	return func(ti *ToolkitInstaller) {
+		ti.defaultRuntimeExecutablePath = path
+	}
+}

cmd/nvidia-ctk-installer/toolkit/toolkit.go

@@ -19,6 +19,7 @@ package toolkit
 import (
 	"fmt"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"strings"
 
@@ -295,18 +296,42 @@ func (t *Installer) Install(cli *cli.Command, opts *Options) error {
 		t.logger.Errorf("Ignoring error: %v", fmt.Errorf("error removing toolkit directory: %v", err))
 	}
 
+	// Loop through the low-level runtime binary paths and pick the first valid PATH resolvable runtime binary
+	// as the fallback for the nvidia-container-runtime wrapper
+	var defaultRuntimeExecutable string
+	t.logger.Infof("WE HAVE container runtimes: %v", opts.ContainerRuntimeRuntimes)
+	if len(opts.ContainerRuntimeRuntimes) > 0 {
+		for _, r := range opts.ContainerRuntimeRuntimes {
+			t.logger.Infof("CHECKING container runtime: %s", r)
+			_, err := exec.LookPath(r)
+			if err == nil {
+				defaultRuntimeExecutable = r
+				break
+			}
+		}
+	}
+
+	// If there are no valid low-level runtime binaries from opts.ContainerRuntimeRuntimes (highly unlikely),
+	// we fall back to old default "runc"
+	if len(defaultRuntimeExecutable) == 0 {
+		t.logger.Infof("SHOULD NOT ENTER HERE")
+		defaultRuntimeExecutable = "runc"
+	}
+
 	// Create a toolkit installer to actually install the toolkit components.
 	toolkit, err := installer.New(
 		installer.WithLogger(t.logger),
 		installer.WithSourceRoot(t.sourceRoot),
 		installer.WithIgnoreErrors(opts.ignoreErrors),
+		installer.WithDefaultRuntimeExecutablePath(defaultRuntimeExecutable),
 	)
 	if err != nil {
 		if !opts.ignoreErrors {
 			return fmt.Errorf("could not create toolkit installer: %w", err)
 		}
 		t.logger.Errorf("Ignoring error: %v", fmt.Errorf("could not create toolkit installer: %w", err))
 	}
+
 	if err := toolkit.Install(t.toolkitRoot); err != nil {
 		if !opts.ignoreErrors {
 			return fmt.Errorf("could not install toolkit components: %w", err)