Merge pull request #1365 from NVIDIA/install-wrapper-default-runtime-exec-path

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

Author: tariq1890

cmd/nvidia-ctk-installer/main.go

@@ -211,7 +211,7 @@ func (a *app) Run(c *cli.Command, o *options) error {
 		o.toolkitOptions.ContainerRuntimeRuntimes = lowlevelRuntimePaths
 	}
 
-	err = a.toolkit.Install(c, &o.toolkitOptions)
+	err = a.toolkit.Install(c, &o.toolkitOptions, o.runtime)
 	if err != nil {
 		return fmt.Errorf("unable to install toolkit: %v", err)
 	}

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

@@ -102,6 +102,12 @@ func (t *ToolkitInstaller) collectExecutables(destDir string) ([]Installer, erro
 			w.Envvars[k] = v
 		}
 
+		if len(t.defaultRuntimeExecutablePath) > 0 {
+			w.DefaultRuntimeExecutablePath = t.defaultRuntimeExecutablePath
+		} else {
+			w.DefaultRuntimeExecutablePath = "runc"
+		}
+
 		installers = append(installers, w)
 
 		if executable.symlink == "" {
@@ -119,10 +125,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 +162,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

@@ -26,6 +26,7 @@ import (
 	"tags.cncf.io/container-device-interface/pkg/cdi"
 	"tags.cncf.io/container-device-interface/pkg/parser"
 
+	"github.com/NVIDIA/nvidia-container-toolkit/cmd/nvidia-ctk-installer/container/runtime/crio"
 	"github.com/NVIDIA/nvidia-container-toolkit/cmd/nvidia-ctk-installer/toolkit/installer"
 	"github.com/NVIDIA/nvidia-container-toolkit/internal/config"
 	"github.com/NVIDIA/nvidia-container-toolkit/internal/logger"
@@ -281,7 +282,7 @@ func (t *Installer) ValidateOptions(opts *Options) error {
 
 // Install installs the components of the NVIDIA container toolkit.
 // Any existing installation is removed.
-func (t *Installer) Install(cli *cli.Command, opts *Options) error {
+func (t *Installer) Install(cli *cli.Command, opts *Options, runtime string) error {
 	if t == nil {
 		return fmt.Errorf("toolkit installer is not initilized")
 	}
@@ -295,18 +296,35 @@ func (t *Installer) Install(cli *cli.Command, opts *Options) error {
 		t.logger.Errorf("Ignoring error: %v", fmt.Errorf("error removing toolkit directory: %v", err))
 	}
 
+	var defaultRuntimeExecutable string
+	if len(opts.ContainerRuntimeRuntimes) > 0 {
+		defaultRuntimeExecutable = opts.ContainerRuntimeRuntimes[0]
+	}
+
+	// If opts.ContainerRuntimeRuntimes is empty (highly unlikely), we fall back to either runc or crun
+	// depending on the runtime
+	if len(defaultRuntimeExecutable) == 0 {
+		if runtime == crio.Name {
+			defaultRuntimeExecutable = "crun"
+		} else {
+			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)

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

@@ -156,7 +156,7 @@ containerEdits:
 			)
 			require.NoError(t, ti.ValidateOptions(&options))
 
-			err := ti.Install(&cli.Command{}, &options)
+			err := ti.Install(&cli.Command{}, &options, "containerd")
 			if tc.expectedError == nil {
 				require.NoError(t, err)
 			} else {