UniqAI/nvidia-container-toolkit
1
0
Fork 0
mirror of https://github.com/NVIDIA/nvidia-container-toolkit synced 2025-06-26 18:18:24 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Refactor Toml config handling

Browse Source 
This change refactors the toml config file handlig for runtimes
such as containerd or crio. A toml.Loader is introduced that
encapsulates loading the required file.

This can be extended to allow other mechanisms for loading
loading the current config.

Signed-off-by: Evan Lezar <elezar@nvidia.com>
This commit is contained in:
Evan Lezar
2024-08-08 16:27:07 +02:00
parent 6c5f4eea63
commit bf2bdfd35e
20 changed files with 428 additions and 229 deletions
Download Patch File Download Diff File Expand all files Collapse all files

61
pkg/config/engine/config.go
View File

@@ -1,61 +0,0 @@
/**
# Copyright (c) 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 engine
import (
"fmt"
"os"
"path/filepath"
)
// Config represents a runtime config
type Config string
// Write writes the specified contents to a config file.
func (c Config) Write(output []byte) (int, error) {
path := string(c)
if path == "" {
n, err := os.Stdout.Write(output)
if err == nil {
os.Stdout.WriteString("\n")
}
return n, err
}
if len(output) == 0 {
err := os.Remove(path)
if err != nil {
return 0, fmt.Errorf("unable to remove empty file: %v", err)
}
return 0, nil
}
if dir := filepath.Dir(path); dir != "" {
err := os.MkdirAll(dir, 0755)
if err != nil {
return 0, fmt.Errorf("unable to create directory %v: %v", dir, err)
}
}
f, err := os.Create(path)
if err != nil {
return 0, fmt.Errorf("unable to open %v for writing: %v", path, err)
}
defer f.Close()
return f.Write(output)
}

12
pkg/config/engine/containerd/config_v1.go
View File

@@ -45,12 +45,14 @@ func (c *ConfigV1) AddRuntime(name string, path string, setAsDefault bool) error
runtimeNamesForConfig = append(runtimeNamesForConfig, name)
}
for _, r := range runtimeNamesForConfig {
if options, ok := config.GetPath([]string{"plugins", "cri", "containerd", "runtimes", r}).(*toml.Tree); ok {
c.Logger.Debugf("using options from runtime %v: %v", r, options.String())
options, _ = toml.Load(options.String())
config.SetPath([]string{"plugins", "cri", "containerd", "runtimes", name}, options)
break
options := config.GetSubtreeByPath([]string{"plugins", "cri", "containerd", "runtimes", r})
if options == nil {
continue
}
c.Logger.Debugf("using options from runtime %v: %v", r, options)
config.SetPath([]string{"plugins", "cri", "containerd", "runtimes", name}, options.Copy())
break
}
if config.GetPath([]string{"plugins", "cri", "containerd", "runtimes", name}) == nil {

9
pkg/config/engine/containerd/config_v1_test.go
View File

@@ -19,9 +19,10 @@ package containerd
import (
"testing"
"github.com/pelletier/go-toml"
testlog "github.com/sirupsen/logrus/hooks/test"
"github.com/stretchr/testify/require"
"github.com/NVIDIA/nvidia-container-toolkit/pkg/config/toml"
)
func TestAddRuntimeV1(t *testing.T) {
@@ -199,20 +200,20 @@ func TestAddRuntimeV1(t *testing.T) {
for _, tc := range testCases {
t.Run(tc.description, func(t *testing.T) {
config, err := toml.Load(tc.config)
cfg, err := toml.Load(tc.config)
require.NoError(t, err)
expectedConfig, err := toml.Load(tc.expectedConfig)
require.NoError(t, err)
c := &ConfigV1{
Logger: logger,
Tree: config,
Tree: cfg,
}
err = c.AddRuntime("test", "/usr/bin/test", tc.setAsDefault)
require.NoError(t, err)
require.EqualValues(t, expectedConfig.String(), config.String())
require.EqualValues(t, expectedConfig.String(), cfg.String())
})
}
}

27
pkg/config/engine/containerd/config_v2.go
View File

@@ -19,9 +19,7 @@ package containerd
import (
"fmt"
"github.com/pelletier/go-toml"
"github.com/NVIDIA/nvidia-container-toolkit/pkg/config/engine"
"github.com/NVIDIA/nvidia-container-toolkit/pkg/config/toml"
)
// AddRuntime adds a runtime to the containerd config
@@ -39,12 +37,13 @@ func (c *Config) AddRuntime(name string, path string, setAsDefault bool) error {
runtimeNamesForConfig = append(runtimeNamesForConfig, name)
}
for _, r := range runtimeNamesForConfig {
if options, ok := config.GetPath([]string{"plugins", "io.containerd.grpc.v1.cri", "containerd", "runtimes", r}).(*toml.Tree); ok {
c.Logger.Debugf("using options from runtime %v: %v", r, options.String())
options, _ = toml.Load(options.String())
config.SetPath([]string{"plugins", "io.containerd.grpc.v1.cri", "containerd", "runtimes", name}, options)
break
options := config.GetSubtreeByPath([]string{"plugins", "io.containerd.grpc.v1.cri", "containerd", "runtimes", r})
if options == nil {
continue
}
c.Logger.Debugf("using options from runtime %v: %v", r, options)
config.SetPath([]string{"plugins", "io.containerd.grpc.v1.cri", "containerd", "runtimes", name}, options.Copy())
break
}
if config.GetPath([]string{"plugins", "io.containerd.grpc.v1.cri", "containerd", "runtimes", name}) == nil {
@@ -146,15 +145,3 @@ func (c *Config) RemoveRuntime(name string) error {
*c.Tree = config
return nil
}
// Save writes the config to the specified path
func (c Config) Save(path string) (int64, error) {
config := c.Tree
output, err := config.Marshal()
if err != nil {
return 0, fmt.Errorf("unable to convert to TOML: %v", err)
}
n, err := engine.Config(path).Write(output)
return int64(n), err
}

9
pkg/config/engine/containerd/config_v2_test.go
View File

@@ -19,9 +19,10 @@ package containerd
import (
"testing"
"github.com/pelletier/go-toml"
testlog "github.com/sirupsen/logrus/hooks/test"
"github.com/stretchr/testify/require"
"github.com/NVIDIA/nvidia-container-toolkit/pkg/config/toml"
)
func TestAddRuntime(t *testing.T) {
@@ -198,20 +199,20 @@ func TestAddRuntime(t *testing.T) {
for _, tc := range testCases {
t.Run(tc.description, func(t *testing.T) {
config, err := toml.Load(tc.config)
cfg, err := toml.Load(tc.config)
require.NoError(t, err)
expectedConfig, err := toml.Load(tc.expectedConfig)
require.NoError(t, err)
c := &Config{
Logger: logger,
Tree: config,
Tree: cfg,
}
err = c.AddRuntime("test", "/usr/bin/test", tc.setAsDefault)
require.NoError(t, err)
require.EqualValues(t, expectedConfig.String(), config.String())
require.EqualValues(t, expectedConfig.String(), cfg.String())
})
}
}

59
pkg/config/engine/containerd/containerd.go
View File

@@ -17,10 +17,11 @@
package containerd
import (
"github.com/pelletier/go-toml"
"fmt"
"github.com/NVIDIA/nvidia-container-toolkit/internal/logger"
"github.com/NVIDIA/nvidia-container-toolkit/pkg/config/engine"
"github.com/NVIDIA/nvidia-container-toolkit/pkg/config/toml"
)
// Config represents the containerd config
@@ -36,14 +37,64 @@ var _ engine.Interface = (*Config)(nil)
// New creates a containerd config with the specified options
func New(opts ...Option) (engine.Interface, error) {
b := &builder{}
b := &builder{
runtimeType: defaultRuntimeType,
}
for _, opt := range opts {
opt(b)
}
if b.logger == nil {
b.logger = logger.New()
}
if b.configSource == nil {
b.configSource = toml.FromFile(b.path)
}
return b.build()
tomlConfig, err := b.configSource.Load()
if err != nil {
return nil, fmt.Errorf("failed to load config: %v", err)
}
cfg := &Config{
Tree: tomlConfig,
Logger: b.logger,
RuntimeType: b.runtimeType,
UseDefaultRuntimeName: b.useLegacyConfig,
ContainerAnnotations: b.containerAnnotations,
}
version, err := cfg.parseVersion(b.useLegacyConfig)
if err != nil {
return nil, fmt.Errorf("failed to parse config version: %v", err)
}
switch version {
case 1:
return (*ConfigV1)(cfg), nil
case 2:
return cfg, nil
}
return nil, fmt.Errorf("unsupported config version: %v", version)
}
// parseVersion returns the version of the config
func (c *Config) parseVersion(useLegacyConfig bool) (int, error) {
defaultVersion := 2
if useLegacyConfig {
defaultVersion = 1
}
switch v := c.Get("version").(type) {
case nil:
switch len(c.Keys()) {
case 0: // No config exists, or the config file is empty, use version inferred from containerd
return defaultVersion, nil
default: // A config file exists, has content, and no version is set
return 1, nil
}
case int64:
return int(v), nil
default:
return -1, fmt.Errorf("unsupported type for version field: %v", v)
}
}

94
pkg/config/engine/containerd/option.go
View File

@@ -17,13 +17,8 @@
package containerd
import (
"fmt"
"os"
"github.com/pelletier/go-toml"
"github.com/NVIDIA/nvidia-container-toolkit/internal/logger"
"github.com/NVIDIA/nvidia-container-toolkit/pkg/config/engine"
"github.com/NVIDIA/nvidia-container-toolkit/pkg/config/toml"
)
const (
@@ -32,6 +27,7 @@ const (
type builder struct {
logger logger.Interface
configSource toml.Loader
path string
runtimeType string
useLegacyConfig bool
@@ -55,6 +51,13 @@ func WithPath(path string) Option {
}
}
// WithConfigSource sets the source for the config.
func WithConfigSource(configSource toml.Loader) Option {
return func(b *builder) {
b.configSource = configSource
}
}
// WithRuntimeType sets the runtime type for the config builder
func WithRuntimeType(runtimeType string) Option {
return func(b *builder) {
@@ -75,82 +78,3 @@ func WithContainerAnnotations(containerAnnotations ...string) Option {
b.containerAnnotations = containerAnnotations
}
}
func (b *builder) build() (engine.Interface, error) {
if b.path == "" {
return nil, fmt.Errorf("config path is empty")
}
if b.runtimeType == "" {
b.runtimeType = defaultRuntimeType
}
config, err := b.loadConfig(b.path)
if err != nil {
return nil, fmt.Errorf("failed to load config: %v", err)
}
config.Logger = b.logger
config.RuntimeType = b.runtimeType
config.UseDefaultRuntimeName = !b.useLegacyConfig
config.ContainerAnnotations = b.containerAnnotations
version, err := config.parseVersion(b.useLegacyConfig)
if err != nil {
return nil, fmt.Errorf("failed to parse config version: %v", err)
}
switch version {
case 1:
return (*ConfigV1)(config), nil
case 2:
return config, nil
}
return nil, fmt.Errorf("unsupported config version: %v", version)
}
// loadConfig loads the containerd config from disk
func (b *builder) loadConfig(config string) (*Config, error) {
info, err := os.Stat(config)
if os.IsExist(err) && info.IsDir() {
return nil, fmt.Errorf("config file is a directory")
}
if os.IsNotExist(err) {
b.logger.Infof("Config file does not exist; using empty config")
config = "/dev/null"
} else {
b.logger.Infof("Loading config from %v", config)
}
tomlConfig, err := toml.LoadFile(config)
if err != nil {
return nil, err
}
cfg := Config{
Tree: tomlConfig,
}
return &cfg, nil
}
// parseVersion returns the version of the config
func (c *Config) parseVersion(useLegacyConfig bool) (int, error) {
defaultVersion := 2
if useLegacyConfig {
defaultVersion = 1
}
switch v := c.Get("version").(type) {
case nil:
switch len(c.Keys()) {
case 0: // No config exists, or the config file is empty, use version inferred from containerd
return defaultVersion, nil
default: // A config file exists, has content, and no version is set
return 1, nil
}
case int64:
return int(v), nil
default:
return -1, fmt.Errorf("unsupported type for version field: %v", v)
}
}

39
pkg/config/engine/crio/crio.go
View File

@@ -19,10 +19,9 @@ package crio
import (
"fmt"
"github.com/pelletier/go-toml"
"github.com/NVIDIA/nvidia-container-toolkit/internal/logger"
"github.com/NVIDIA/nvidia-container-toolkit/pkg/config/engine"
"github.com/NVIDIA/nvidia-container-toolkit/pkg/config/toml"
)
// Config represents the cri-o config
@@ -39,8 +38,23 @@ func New(opts ...Option) (engine.Interface, error) {
for _, opt := range opts {
opt(b)
}
if b.logger == nil {
b.logger = logger.New()
}
if b.configSource == nil {
b.configSource = toml.FromFile(b.path)
}
return b.build()
tomlConfig, err := b.configSource.Load()
if err != nil {
return nil, err
}
cfg := Config{
Tree: tomlConfig,
Logger: b.logger,
}
return &cfg, nil
}
// AddRuntime adds a new runtime to the crio config
@@ -115,22 +129,3 @@ func (c *Config) RemoveRuntime(name string) error {
*c.Tree = config
return nil
}
// Set sets the specified cri-o option.
func (c *Config) Set(key string, value interface{}) {
config := *c.Tree
config.Set(key, value)
*c.Tree = config
}
// Save writes the config to the specified path
func (c Config) Save(path string) (int64, error) {
config := c.Tree
output, err := config.Marshal()
if err != nil {
return 0, fmt.Errorf("unable to convert to TOML: %v", err)
}
n, err := engine.Config(path).Write(output)
return int64(n), err
}

9
pkg/config/engine/crio/crio_test.go
View File

@@ -19,9 +19,10 @@ package crio
import (
"testing"
"github.com/pelletier/go-toml"
testlog "github.com/sirupsen/logrus/hooks/test"
"github.com/stretchr/testify/require"
"github.com/NVIDIA/nvidia-container-toolkit/pkg/config/toml"
)
func TestAddRuntime(t *testing.T) {
@@ -126,20 +127,20 @@ func TestAddRuntime(t *testing.T) {
for _, tc := range testCases {
t.Run(tc.description, func(t *testing.T) {
config, err := toml.Load(tc.config)
cfg, err := toml.Load(tc.config)
require.NoError(t, err)
expectedConfig, err := toml.Load(tc.expectedConfig)
require.NoError(t, err)
c := &Config{
Logger: logger,
Tree: config,
Tree: cfg,
}
err = c.AddRuntime("test", "/usr/bin/test", tc.setAsDefault)
require.NoError(t, err)
require.EqualValues(t, expectedConfig.String(), config.String())
require.EqualValues(t, expectedConfig.String(), cfg.String())
})
}
}

58
pkg/config/engine/crio/option.go
View File

@@ -17,17 +17,14 @@
package crio
import (
"fmt"
"os"
"github.com/pelletier/go-toml"
"github.com/NVIDIA/nvidia-container-toolkit/internal/logger"
"github.com/NVIDIA/nvidia-container-toolkit/pkg/config/toml"
)
type builder struct {
logger logger.Interface
path string
logger logger.Interface
configSource toml.Loader
path string
}
// Option defines a function that can be used to configure the config builder
@@ -47,48 +44,9 @@ func WithPath(path string) Option {
}
}
func (b *builder) build() (*Config, error) {
if b.logger == nil {
b.logger = logger.New()
// WithConfigSource sets the TOML source for the config.
func WithConfigSource(configSource toml.Loader) Option {
return func(b *builder) {
b.configSource = configSource
}
if b.path == "" {
empty := toml.Tree{}
c := Config{
Tree: &empty,
Logger: b.logger,
}
return &c, nil
}
return b.loadConfig(b.path)
}
// loadConfig loads the cri-o config from disk
func (b *builder) loadConfig(config string) (*Config, error) {
b.logger.Infof("Loading config: %v", config)
info, err := os.Stat(config)
if os.IsExist(err) && info.IsDir() {
return nil, fmt.Errorf("config file is a directory")
}
if os.IsNotExist(err) {
b.logger.Infof("Config file does not exist; using empty config")
config = "/dev/null"
} else {
b.logger.Infof("Loading config from %v", config)
}
cfg, err := toml.LoadFile(config)
if err != nil {
return nil, err
}
b.logger.Infof("Successfully loaded config")
c := Config{
Tree: cfg,
Logger: b.logger,
}
return &c, nil
}

3
pkg/config/engine/docker/docker.go
View File

@@ -21,6 +21,7 @@ import (
"fmt"
"github.com/NVIDIA/nvidia-container-toolkit/internal/logger"
"github.com/NVIDIA/nvidia-container-toolkit/pkg/config"
"github.com/NVIDIA/nvidia-container-toolkit/pkg/config/engine"
)
@@ -128,6 +129,6 @@ func (c Config) Save(path string) (int64, error) {
return 0, fmt.Errorf("unable to convert to JSON: %v", err)
}
n, err := engine.Config(path).Write(output)
n, err := config.Raw(path).Write(output)
return int64(n), err
}