Load settings from config.toml file during CDI generation

Signed-off-by: Carlos Eduardo Arango Gutierrez <[email protected]>

Author: ArangoGutierrez

cmd/nvidia-cdi-hook/main.go

@@ -80,7 +80,7 @@ func main() {
 			Usage:       "Suppress all output except for errors; overrides --debug",
 			Destination: &opts.Quiet,
 			// TODO: Support for NVIDIA_CDI_QUIET is deprecated and NVIDIA_CTK_QUIET should be used instead.
-			Sources: cli.EnvVars("NVDIA_CTK_QUIET", "NVIDIA_CDI_QUIET"),
+			Sources: cli.EnvVars("NVIDIA_CTK_QUIET", "NVIDIA_CDI_QUIET"),
 		},
 	}
 

cmd/nvidia-ctk/cdi/cdi.go

@@ -17,39 +17,41 @@
 package cdi
 
 import (
+	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v3"
 
 	"github.com/NVIDIA/nvidia-container-toolkit/cmd/nvidia-ctk/cdi/generate"
 	"github.com/NVIDIA/nvidia-container-toolkit/cmd/nvidia-ctk/cdi/list"
 	"github.com/NVIDIA/nvidia-container-toolkit/cmd/nvidia-ctk/cdi/transform"
-	"github.com/NVIDIA/nvidia-container-toolkit/internal/logger"
 )
 
 type command struct {
-	logger logger.Interface
+	logger     *logrus.Logger
+	configFile *string
 }
 
-// NewCommand constructs an info command with the specified logger
-func NewCommand(logger logger.Interface) *cli.Command {
+// NewCommand constructs a cdi command with the specified logger
+func NewCommand(logger *logrus.Logger, configFile *string) *cli.Command {
 	c := command{
-		logger: logger,
+		logger:     logger,
+		configFile: configFile,
 	}
 	return c.build()
 }
 
 // build
 func (m command) build() *cli.Command {
-	// Create the 'hook' command
-	hook := cli.Command{
+	// Create the 'cdi' command
+	cdi := cli.Command{
 		Name:  "cdi",
 		Usage: "Provide tools for interacting with Container Device Interface specifications",
 	}
 
-	hook.Commands = []*cli.Command{
-		generate.NewCommand(m.logger),
-		transform.NewCommand(m.logger),
-		list.NewCommand(m.logger),
+	cdi.Commands = []*cli.Command{
+		generate.NewCommand(m.logger, m.configFile),
+		list.NewCommand(m.logger, m.configFile),
+		transform.NewCommand(m.logger, m.configFile),
 	}
 
-	return &hook
+	return &cdi
 }

cmd/nvidia-ctk/cdi/generate/config.go

@@ -0,0 +1,139 @@
+/**
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+**/
+
+package generate
+
+import (
+	"fmt"
+	"sync"
+
+	"github.com/NVIDIA/nvidia-container-toolkit/internal/config"
+
+	altsrc "github.com/urfave/cli-altsrc/v3"
+	"github.com/urfave/cli/v3"
+)
+
+// Config returns a configAsValueSource for the generate options.
+// This allows for flags to be specified in a config file.
+func (o *options) Config() *configAsValueSource {
+	if o.appliedConfig == nil {
+		o.appliedConfig = &configAsValueSource{}
+	}
+	return o.appliedConfig.From(&o.config)
+}
+
+// configAsValueSource provides flag values from a TOML configuration file, acting as a factory for specific cli.ValueSource instances.
+// It uses an altsrc.Sourcer to find the configuration file path and loads it on demand.
+type configAsValueSource struct {
+	sync.Mutex
+	source altsrc.Sourcer
+	*config.Toml
+}
+
+// configValueLookup is a cli.ValueSource that looks up values from a configAsValueSource.
+type configValueLookup struct {
+	key  string
+	from *configAsValueSource
+}
+
+// From sets the source for the config file path.
+// It uses a string pointer to the config file path option.
+func (c *configAsValueSource) From(config *string) *configAsValueSource {
+	c.Lock()
+	defer c.Unlock()
+	if c.source == nil {
+		c.source = altsrc.NewStringPtrSourcer(config)
+	}
+	return c
+}
+
+// LoadIfRequired loads the config file if it has not already been loaded.
+// If the config file path is not specified, it uses the default config file path.
+func (c *configAsValueSource) LoadIfRequired() error {
+	c.Lock()
+	defer c.Unlock()
+
+	if c.Toml != nil {
+		return nil
+	}
+
+	configFilePath := c.source.SourceURI()
+
+	if configFilePath == "" {
+		configFilePath = config.GetConfigFilePath()
+	}
+	configToml, err := config.New(
+		config.WithConfigFile(configFilePath),
+	)
+	if err != nil {
+		return err
+	}
+	c.Toml = configToml
+
+	return nil
+}
+
+// GetAsString gets the specified key from the config file as a string.
+// It returns the value and a boolean indicating if the value was found.
+func (c *configAsValueSource) GetAsString(key string) (string, bool) {
+	if c == nil {
+		return "", false
+	}
+	if err := c.LoadIfRequired(); err != nil {
+		return "", false
+	}
+
+	value := c.Get(key)
+	if key == value {
+		return "", false
+	}
+
+	return fmt.Sprintf("%v", value), true
+}
+
+// ValueSource returns a cli.ValueSource for the given key.
+// This can be used in the Sources chain for a cli.Flag.
+func (c *configAsValueSource) ValueSource(key string) cli.ValueSource {
+	return &configValueLookup{
+		key:  key,
+		from: c,
+	}
+}
+
+// Lookup returns the value for the key from the config file.
+func (c *configValueLookup) Lookup() (string, bool) {
+	return c.from.GetAsString(c.key)
+}
+
+// GoString returns a Go-syntax representation of the configuration source.
+func (c *configValueLookup) GoString() string {
+	return c.String()
+}
+
+// String returns a string representation of the configuration source.
+func (c *configValueLookup) String() string {
+	if c.from == nil || c.from.source == nil {
+		return "config file"
+	}
+	configFile := c.from.source.SourceURI()
+	if configFile == "" {
+		configFile = config.GetConfigFilePath()
+	}
+	if configFile == "" {
+		return "config file"
+	}
+	return fmt.Sprintf("config file %q", configFile)
+}

cmd/nvidia-ctk/cdi/generate/generate.go

@@ -23,25 +23,28 @@ import (
 	"path/filepath"
 	"strings"
 
+	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v3"
+
 	cdi "tags.cncf.io/container-device-interface/pkg/parser"
 
 	"github.com/NVIDIA/go-nvml/pkg/nvml"
 
 	"github.com/NVIDIA/nvidia-container-toolkit/internal/config"
-	"github.com/NVIDIA/nvidia-container-toolkit/internal/logger"
 	"github.com/NVIDIA/nvidia-container-toolkit/internal/platform-support/tegra/csv"
 	"github.com/NVIDIA/nvidia-container-toolkit/pkg/nvcdi"
 	"github.com/NVIDIA/nvidia-container-toolkit/pkg/nvcdi/spec"
 	"github.com/NVIDIA/nvidia-container-toolkit/pkg/nvcdi/transform"
 )
 
 const (
-	allDeviceName = "all"
+	allDeviceName        = "all"
+	defaultNvidiaCTKPath = "/usr/bin/nvidia-ctk"
 )
 
 type command struct {
-	logger logger.Interface
+	logger     *logrus.Logger
+	configFile *string
 }
 
 type options struct {
@@ -60,19 +63,24 @@ type options struct {
 	librarySearchPaths []string
 	disabledHooks      []string
 
+	config string
+
 	csv struct {
 		files          []string
 		ignorePatterns []string
 	}
 
+	appliedConfig *configAsValueSource
+
 	// the following are used for dependency injection during spec generation.
 	nvmllib nvml.Interface
 }
 
 // NewCommand constructs a generate-cdi command with the specified logger
-func NewCommand(logger logger.Interface) *cli.Command {
+func NewCommand(logger *logrus.Logger, configFile *string) *cli.Command {
 	c := command{
-		logger: logger,
+		logger:     logger,
+		configFile: configFile,
 	}
 	return c.build()
 }
@@ -81,21 +89,24 @@ func NewCommand(logger logger.Interface) *cli.Command {
 func (m command) build() *cli.Command {
 	opts := options{}
 
+	var flags []cli.Flag
+
 	// Create the 'generate-cdi' command
 	c := cli.Command{
 		Name:                   "generate",
 		Usage:                  "Generate CDI specifications for use with CDI-enabled runtimes",
 		UseShortOptionHandling: true,
 		EnableShellCompletion:  true,
 		Before: func(ctx context.Context, cmd *cli.Command) (context.Context, error) {
+			opts.config = *m.configFile
 			return ctx, m.validateFlags(cmd, &opts)
 		},
 		Action: func(ctx context.Context, cmd *cli.Command) error {
 			return m.run(&opts)
 		},
 	}
 
-	c.Flags = []cli.Flag{
+	flags = []cli.Flag{
 		&cli.StringSliceFlag{
 			Name:        "config-search-path",
 			Usage:       "Specify the path to search for config files when discovering the entities that should be included in the CDI specification.",
@@ -123,7 +134,10 @@ func (m command) build() *cli.Command {
 				"If mode is set to 'auto' the mode will be determined based on the system configuration.",
 			Value:       string(nvcdi.ModeAuto),
 			Destination: &opts.mode,
-			Sources:     cli.EnvVars("NVIDIA_CTK_CDI_GENERATE_MODE"),
+			Sources: cli.NewValueSourceChain(
+				cli.EnvVar("NVIDIA_CTK_CDI_GENERATE_MODE"),
+				opts.Config().ValueSource("nvidia-container-runtime.mode"),
+			),
 		},
 		&cli.StringFlag{
 			Name:        "dev-root",
@@ -142,7 +156,10 @@ func (m command) build() *cli.Command {
 			Name:        "driver-root",
 			Usage:       "Specify the NVIDIA GPU driver root to use when discovering the entities that should be included in the CDI specification.",
 			Destination: &opts.driverRoot,
-			Sources:     cli.EnvVars("NVIDIA_CTK_DRIVER_ROOT"),
+			Sources: cli.NewValueSourceChain(
+				cli.EnvVar("NVIDIA_CTK_DRIVER_ROOT"),
+				opts.Config().ValueSource("nvidia-container-runtime.root"),
+			),
 		},
 		&cli.StringSliceFlag{
 			Name:        "library-search-path",
@@ -163,7 +180,10 @@ func (m command) build() *cli.Command {
 			Name:        "ldconfig-path",
 			Usage:       "Specify the path to use for ldconfig in the generated CDI specification",
 			Destination: &opts.ldconfigPath,
-			Sources:     cli.EnvVars("NVIDIA_CTK_CDI_GENERATE_LDCONFIG_PATH"),
+			Sources: cli.NewValueSourceChain(
+				cli.EnvVar("NVIDIA_CTK_CDI_GENERATE_LDCONFIG_PATH"),
+				opts.Config().ValueSource("nvidia-container-runtime.ldconfig"),
+			),
 		},
 		&cli.StringFlag{
 			Name:        "vendor",
@@ -206,6 +226,8 @@ func (m command) build() *cli.Command {
 		},
 	}
 
+	c.Flags = flags
+
 	return &c
 }
 

cmd/nvidia-ctk/cdi/list/list.go

@@ -21,24 +21,25 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v3"
 	"tags.cncf.io/container-device-interface/pkg/cdi"
-
-	"github.com/NVIDIA/nvidia-container-toolkit/internal/logger"
 )
 
 type command struct {
-	logger logger.Interface
+	logger     *logrus.Logger
+	configFile *string
 }
 
 type config struct {
 	cdiSpecDirs []string
 }
 
 // NewCommand constructs a cdi list command with the specified logger
-func NewCommand(logger logger.Interface) *cli.Command {
+func NewCommand(logger *logrus.Logger, configFile *string) *cli.Command {
 	c := command{
-		logger: logger,
+		logger:     logger,
+		configFile: configFile,
 	}
 	return c.build()
 }

cmd/nvidia-ctk/cdi/transform/transform.go

@@ -17,20 +17,22 @@
 package transform
 
 import (
+	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v3"
 
 	"github.com/NVIDIA/nvidia-container-toolkit/cmd/nvidia-ctk/cdi/transform/root"
-	"github.com/NVIDIA/nvidia-container-toolkit/internal/logger"
 )
 
 type command struct {
-	logger logger.Interface
+	logger     *logrus.Logger
+	configFile *string
 }
 
-// NewCommand constructs a command with the specified logger
-func NewCommand(logger logger.Interface) *cli.Command {
+// NewCommand constructs a transform command with the specified logger.
+func NewCommand(logger *logrus.Logger, configFile *string) *cli.Command {
 	c := command{
-		logger: logger,
+		logger:     logger,
+		configFile: configFile,
 	}
 	return c.build()
 }