From 6bcb6bf40396e9dae30f748d5ad230359d6696af Mon Sep 17 00:00:00 2001 From: Cyclinder Date: Mon, 11 Apr 2022 23:22:48 +0800 Subject: [PATCH] add some flags for customize the log settings (#817) --- cmd/controller/main.go | 34 +++++++++++++++++ docs/configuration.md | 27 +++++++++++++ pkg/config/generator.go | 60 +++++++++++++++++++++++++++++ pkg/config/generator_test.go | 74 ++++++++++++++++++++++++++++++++++++ pkg/logging/logging.go | 43 +++++++++++++++++---- pkg/logging/logging_test.go | 52 +++++++++++++++++++++++++ pkg/testing/testing.go | 10 +++++ pkg/types/conf.go | 1 + pkg/types/conf_test.go | 57 +++++++++++++++++++-------- pkg/types/types.go | 2 + 10 files changed, 338 insertions(+), 22 deletions(-) diff --git a/cmd/controller/main.go b/cmd/controller/main.go index bd777165e..e07d4361c 100644 --- a/cmd/controller/main.go +++ b/cmd/controller/main.go @@ -40,6 +40,10 @@ const ( defaultMultusGlobalNamespaces = "" defaultMultusKubeconfigPath = "/etc/cni/net.d/multus.d/multus.kubeconfig" defaultMultusLogFile = "" + defaultMultusLogMaxSize = 100 // megabytes + defaultMultusLogMaxAge = 5 // days + defaultMultusLogMaxBackups = 5 + defaultMultusLogCompress = true defaultMultusLogLevel = "" defaultMultusLogToStdErr = false defaultMultusMasterCNIFile = "" @@ -55,6 +59,10 @@ const ( multusConfigFileVarName = "multus-conf-file" multusGlobalNamespaces = "global-namespaces" multusLogFile = "multus-log-file" + multusLogMaxSize = "multus-log-max-size" + multusLogMaxAge = "multus-log-max-age" + multusLogMaxBackups = "multus-log-max-backups" + multusLogCompress = "multus-log-Compress" multusLogLevel = "multus-log-level" multusLogToStdErr = "multus-log-to-stderr" multusKubeconfigPath = "multus-kubeconfig-file-host" @@ -76,6 +84,10 @@ func main() { logToStdErr := flag.Bool(multusLogToStdErr, defaultMultusLogToStdErr, "If the multus logs are also to be echoed to stderr.") logLevel := flag.String(multusLogLevel, defaultMultusLogLevel, "One of: debug/verbose/error/panic. Used only with --multus-conf-file=auto.") logFile := flag.String(multusLogFile, defaultMultusLogFile, "Path where to multus will log. Used only with --multus-conf-file=auto.") + logMaxSize := flag.Int(multusLogMaxSize, defaultMultusLogMaxSize, "the maximum size in megabytes of the log file before it gets rotated") + logMaxAge := flag.Int(multusLogMaxAge, defaultMultusLogMaxAge, "the maximum number of days to retain old log files in their filename") + logMaxBackups := flag.Int(multusLogMaxBackups, defaultMultusLogMaxBackups, "the maximum number of old log files to retain") + logCompress := flag.Bool(multusLogCompress, defaultMultusLogCompress, "compress determines if the rotated log files should be compressed using gzip") cniVersion := flag.String(multusCNIVersion, defaultMultusCNIVersion, "Allows you to specify CNI spec version. Used only with --multus-conf-file=auto.") additionalBinDir := flag.String(multusAdditionalBinDirVarName, defaultMultusAdditionalBinDir, "Additional binary directory to specify in the configurations. Used only with --multus-conf-file=auto.") readinessIndicator := flag.String(multusReadinessIndicatorFile, defaultMultusReadinessIndicatorFile, "Which file should be used as the readiness indicator. Used only with --multus-conf-file=auto.") @@ -140,6 +152,28 @@ func main() { configurationOptions, config.WithReadinessFileIndicator(*readinessIndicator)) } + // logOptions + + var logOptionFuncs []config.LogOptionFunc + if *logMaxAge != defaultMultusLogMaxAge { + logOptionFuncs = append(logOptionFuncs, config.WithLogMaxAge(logMaxAge)) + } + if *logMaxSize != defaultMultusLogMaxSize { + logOptionFuncs = append(logOptionFuncs, config.WithLogMaxSize(logMaxSize)) + } + if *logMaxBackups != defaultMultusLogMaxBackups { + logOptionFuncs = append(logOptionFuncs, config.WithLogMaxBackups(logMaxBackups)) + } + if *logCompress != defaultMultusLogCompress { + logOptionFuncs = append(logOptionFuncs, config.WithLogCompress(logCompress)) + } + + if len(logOptionFuncs) > 0 { + logOptions := &config.LogOptions{} + config.MutateLogOptions(logOptions, logOptionFuncs...) + configurationOptions = append(configurationOptions, config.WithLogOptions(logOptions)) + } + multusConfig, err := config.NewMultusConfig(multusPluginName, *cniVersion, *multusKubeconfig, configurationOptions...) if err != nil { _ = logging.Errorf("Failed to create multus config: %v", err) diff --git a/docs/configuration.md b/docs/configuration.md index 5b6a8cf68..5106a0cd5 100644 --- a/docs/configuration.md +++ b/docs/configuration.md @@ -14,6 +14,12 @@ Following is the example of multus config file, in `/etc/cni/net.d/`. "binDir": "/opt/cni/bin", "logFile": "/var/log/multus.log", "logLevel": "debug", + "logOptions": { + "maxAge": 5, + "maxSize": 100, + "maxBackups": 5, + "compress": true + }, "capabilities": { "portMappings": true }, @@ -44,6 +50,7 @@ Following is the example of multus config file, in `/etc/cni/net.d/`. * `logToStderr` (bool, optional): Enable or disable logging to `STDERR`. Defaults to true. * `logFile` (string, optional): file path for log file. multus puts log in given file * `logLevel` (string, optional): logging level ("debug", "error", "verbose", or "panic") +* `logOptions` (object, optional): logging option, More detailed log configuration * `namespaceIsolation` (boolean, optional): Enables a security feature where pods are only allowed to access `NetworkAttachmentDefinitions` in the namespace where the pod resides. Defaults to false. * `capabilities` ({}list, optional): [capabilities](https://github.com/containernetworking/cni/blob/master/CONVENTIONS.md#dynamic-plugin-specific-fields-capabilities--runtime-configuration) supported by at least one of the delegates. (NOTE: Multus only supports portMappings/Bandwidth capability for cluster networks). * `readinessindicatorfile`: The path to a file whose existence denotes that the default network is ready @@ -123,6 +130,26 @@ You may configure the logging level by using the `LogLevel` option in your CNI c "LogLevel": "debug", ``` +#### Logging Options + +If you want a more detailed configuration of the logging, This includes the following parameters: + +* `maxAge` the maximum number of days to retain old log files in their filename +* `maxSize` the maximum size in megabytes of the log file before it gets rotated +* `maxBackups` the maximum number of days to retain old log files in their filename +* `compress` compress determines if the rotated log files should be compressed using gzip + +For example in your CNI configuration, you may set: + +``` + "logOptions": { + "maxAge": 5, + "maxSize": 100, + "maxBackups": 5, + "compress": true + } +``` + ### Namespace Isolation The functionality provided by the `namespaceIsolation` configuration option enables a mode where Multus only allows pods to access custom resources (the `NetworkAttachmentDefinitions`) within the namespace where that pod resides. In other words, the `NetworkAttachmentDefinitions` are isolated to usage within the namespace in which they're created. diff --git a/pkg/config/generator.go b/pkg/config/generator.go index 32f022d5b..f60507c5e 100644 --- a/pkg/config/generator.go +++ b/pkg/config/generator.go @@ -33,6 +33,9 @@ const ( singleConfigCapabilityKey = "capabilities" ) +// LogOptionFunc mutates the `LoggingOptions` object +type LogOptionFunc func(logOptions *LogOptions) + // Option mutates the `conf` object type Option func(conf *MultusConf) @@ -45,6 +48,7 @@ type MultusConf struct { LogFile string `json:"logFile,omitempty"` LogLevel string `json:"logLevel,omitempty"` LogToStderr bool `json:"logToStderr,omitempty"` + LogOptions *LogOptions `json:"logOptions,omitempty"` Kubeconfig string `json:"kubeconfig"` Name string `json:"name"` NamespaceIsolation bool `json:"namespaceIsolation,omitempty"` @@ -53,6 +57,14 @@ type MultusConf struct { Type string `json:"type"` } +// LogOptions specifies the configuration of the log +type LogOptions struct { + MaxAge *int `json:"maxAge,omitempty"` + MaxSize *int `json:"maxSize,omitempty"` + MaxBackups *int `json:"maxBackups,omitempty"` + Compress *bool `json:"compress,omitempty"` +} + // NewMultusConfig creates a basic configuration generator. It can be mutated // via the `With...` methods. func NewMultusConfig(pluginName string, cniVersion string, kubeconfig string, configurationOptions ...Option) (*MultusConf, error) { @@ -162,6 +174,14 @@ func WithLogFile(logFile string) Option { } } +// WithLogOptions mutates the inner state to set the +// LogOptions attribute +func WithLogOptions(logOptions *LogOptions) Option { + return func(conf *MultusConf) { + conf.LogOptions = logOptions + } +} + // WithReadinessFileIndicator mutates the inner state to set the // ReadinessIndicatorFile attribute func WithReadinessFileIndicator(path string) Option { @@ -219,6 +239,46 @@ func withDelegates(primaryCNIConfigData map[string]interface{}) Option { } } +// MutateLogOptions update the LoggingOptions of the MultusConf according +// to the provided configuration `loggingOptions` +func MutateLogOptions(logOption *LogOptions, logOptionFunc ...LogOptionFunc) { + for _, loggingOption := range logOptionFunc { + loggingOption(logOption) + } +} + +// WithLogMaxSize mutates the inner state to set the +// logMaxSize attribute +func WithLogMaxSize(maxSize *int) LogOptionFunc { + return func(logOptions *LogOptions) { + logOptions.MaxSize = maxSize + } +} + +// WithLogMaxAge mutates the inner state to set the +// logMaxAge attribute +func WithLogMaxAge(maxAge *int) LogOptionFunc { + return func(logOptions *LogOptions) { + logOptions.MaxAge = maxAge + } +} + +// WithLogMaxBackups mutates the inner state to set the +// logMaxBackups attribute +func WithLogMaxBackups(maxBackups *int) LogOptionFunc { + return func(logOptions *LogOptions) { + logOptions.MaxBackups = maxBackups + } +} + +// WithLogCompress mutates the inner state to set the +// logCompress attribute +func WithLogCompress(compress *bool) LogOptionFunc { + return func(logOptions *LogOptions) { + logOptions.Compress = compress + } +} + func extractCapabilities(capabilitiesInterface interface{}) []string { capabilitiesMap, ok := capabilitiesInterface.(map[string]interface{}) if !ok { diff --git a/pkg/config/generator_test.go b/pkg/config/generator_test.go index cc6c40d5c..2bdc02a0b 100644 --- a/pkg/config/generator_test.go +++ b/pkg/config/generator_test.go @@ -18,6 +18,7 @@ package config import ( "encoding/json" "fmt" + testutils "gopkg.in/k8snetworkplumbingwg/multus-cni.v3/pkg/testing" "testing" ) @@ -102,6 +103,79 @@ func TestMultusConfigWithLoggingConfiguration(t *testing.T) { newTestCase(t, multusConfig.Generate).assertResult(expectedResult) } +func TestMultusConfigWithLogOptionsConfiguration(t *testing.T) { + multusConfig, err := newMultusConfigWithDelegates( + primaryCNIName, + cniVersion, + kubeconfig, + primaryCNIConfig, + WithLogOptions(&LogOptions{ + MaxAge: testutils.Int(5), + MaxSize: testutils.Int(100), + MaxBackups: testutils.Int(5), + Compress: testutils.Bool(true), + })) + assertError(t, err, nil) + expectedResult := "{\"cniVersion\":\"0.4.0\",\"delegates\":[{\"cniVersion\":\"1.0.0\",\"dns\":\"{}\",\"ipam\":\"{}\",\"logFile\":\"/var/log/ovn-kubernetes/ovn-k8s-cni-overlay.log\",\"logLevel\":\"5\",\"logfile-maxage\":5,\"logfile-maxbackups\":5,\"logfile-maxsize\":100,\"name\":\"ovn-kubernetes\",\"type\":\"ovn-k8s-cni-overlay\"}],\"logOptions\":{\"maxAge\":5,\"maxSize\":100,\"maxBackups\":5,\"compress\":true},\"kubeconfig\":\"/a/b/c/kubeconfig.kubeconfig\",\"name\":\"multus-cni-network\",\"type\":\"myCNI\"}" + newTestCase(t, multusConfig.Generate).assertResult(expectedResult) +} + +func TestMultusLogOptionsWithLogMaxAge(t *testing.T) { + logOption := &LogOptions{} + MutateLogOptions(logOption, WithLogMaxAge(testutils.Int(5))) + multusConfig, err := newMultusConfigWithDelegates( + primaryCNIName, + cniVersion, + kubeconfig, + primaryCNIConfig, + WithLogOptions(logOption)) + assertError(t, err, nil) + expectedResult := "{\"cniVersion\":\"0.4.0\",\"delegates\":[{\"cniVersion\":\"1.0.0\",\"dns\":\"{}\",\"ipam\":\"{}\",\"logFile\":\"/var/log/ovn-kubernetes/ovn-k8s-cni-overlay.log\",\"logLevel\":\"5\",\"logfile-maxage\":5,\"logfile-maxbackups\":5,\"logfile-maxsize\":100,\"name\":\"ovn-kubernetes\",\"type\":\"ovn-k8s-cni-overlay\"}],\"logOptions\":{\"maxAge\":5},\"kubeconfig\":\"/a/b/c/kubeconfig.kubeconfig\",\"name\":\"multus-cni-network\",\"type\":\"myCNI\"}" + newTestCase(t, multusConfig.Generate).assertResult(expectedResult) +} + +func TestMultusLogOptionsWithLogMaxSize(t *testing.T) { + logOption := &LogOptions{} + MutateLogOptions(logOption, WithLogMaxSize(testutils.Int(100))) + multusConfig, err := newMultusConfigWithDelegates( + primaryCNIName, + cniVersion, + kubeconfig, + primaryCNIConfig, + WithLogOptions(logOption)) + assertError(t, err, nil) + expectedResult := "{\"cniVersion\":\"0.4.0\",\"delegates\":[{\"cniVersion\":\"1.0.0\",\"dns\":\"{}\",\"ipam\":\"{}\",\"logFile\":\"/var/log/ovn-kubernetes/ovn-k8s-cni-overlay.log\",\"logLevel\":\"5\",\"logfile-maxage\":5,\"logfile-maxbackups\":5,\"logfile-maxsize\":100,\"name\":\"ovn-kubernetes\",\"type\":\"ovn-k8s-cni-overlay\"}],\"logOptions\":{\"maxSize\":100},\"kubeconfig\":\"/a/b/c/kubeconfig.kubeconfig\",\"name\":\"multus-cni-network\",\"type\":\"myCNI\"}" + newTestCase(t, multusConfig.Generate).assertResult(expectedResult) +} + +func TestMultusLogOptionsWithLogBackups(t *testing.T) { + logOption := &LogOptions{} + MutateLogOptions(logOption, WithLogMaxBackups(testutils.Int(5))) + multusConfig, err := newMultusConfigWithDelegates( + primaryCNIName, + cniVersion, + kubeconfig, + primaryCNIConfig, + WithLogOptions(logOption)) + assertError(t, err, nil) + expectedResult := "{\"cniVersion\":\"0.4.0\",\"delegates\":[{\"cniVersion\":\"1.0.0\",\"dns\":\"{}\",\"ipam\":\"{}\",\"logFile\":\"/var/log/ovn-kubernetes/ovn-k8s-cni-overlay.log\",\"logLevel\":\"5\",\"logfile-maxage\":5,\"logfile-maxbackups\":5,\"logfile-maxsize\":100,\"name\":\"ovn-kubernetes\",\"type\":\"ovn-k8s-cni-overlay\"}],\"logOptions\":{\"maxBackups\":5},\"kubeconfig\":\"/a/b/c/kubeconfig.kubeconfig\",\"name\":\"multus-cni-network\",\"type\":\"myCNI\"}" + newTestCase(t, multusConfig.Generate).assertResult(expectedResult) +} + +func TestMultusLogOptionsWithLogCompress(t *testing.T) { + logOption := &LogOptions{} + MutateLogOptions(logOption, WithLogCompress(testutils.Bool(true))) + multusConfig, err := newMultusConfigWithDelegates( + primaryCNIName, + cniVersion, + kubeconfig, + primaryCNIConfig, + WithLogOptions(logOption)) + assertError(t, err, nil) + expectedResult := "{\"cniVersion\":\"0.4.0\",\"delegates\":[{\"cniVersion\":\"1.0.0\",\"dns\":\"{}\",\"ipam\":\"{}\",\"logFile\":\"/var/log/ovn-kubernetes/ovn-k8s-cni-overlay.log\",\"logLevel\":\"5\",\"logfile-maxage\":5,\"logfile-maxbackups\":5,\"logfile-maxsize\":100,\"name\":\"ovn-kubernetes\",\"type\":\"ovn-k8s-cni-overlay\"}],\"logOptions\":{\"compress\":true},\"kubeconfig\":\"/a/b/c/kubeconfig.kubeconfig\",\"name\":\"multus-cni-network\",\"type\":\"myCNI\"}" + newTestCase(t, multusConfig.Generate).assertResult(expectedResult) +} + func TestMultusConfigWithGlobalNamespace(t *testing.T) { const globalNamespace = "come-along-ns" multusConfig, err := newMultusConfigWithDelegates( diff --git a/pkg/logging/logging.go b/pkg/logging/logging.go index 53be4a070..cda19a729 100644 --- a/pkg/logging/logging.go +++ b/pkg/logging/logging.go @@ -41,9 +41,42 @@ const ( var loggingStderr bool var loggingW io.Writer var loggingLevel Level +var logger *lumberjack.Logger const defaultTimestampFormat = time.RFC3339 +// LogOptions specifies the configuration of the log +type LogOptions struct { + MaxAge *int `json:"maxAge,omitempty"` + MaxSize *int `json:"maxSize,omitempty"` + MaxBackups *int `json:"maxBackups,omitempty"` + Compress *bool `json:"compress,omitempty"` +} + +// SetLogOptions set the LoggingOptions of NetConf +func SetLogOptions(options *LogOptions) { + // give some default value + logger.MaxSize = 100 + logger.MaxAge = 5 + logger.MaxBackups = 5 + logger.Compress = true + if options != nil { + if options.MaxAge != nil { + logger.MaxAge = *options.MaxAge + } + if options.MaxSize != nil { + logger.MaxSize = *options.MaxSize + } + if options.MaxBackups != nil { + logger.MaxBackups = *options.MaxBackups + } + if options.Compress != nil { + logger.Compress = *options.Compress + } + } + loggingW = logger +} + func (l Level) String() string { switch l { case PanicLevel: @@ -141,13 +174,8 @@ func SetLogFile(filename string) { return } - loggingW = &lumberjack.Logger{ - Filename: filename, - MaxSize: 100, // megabytes - MaxBackups: 5, - MaxAge: 5, // days - Compress: true, - } + logger.Filename = filename + loggingW = logger } @@ -155,4 +183,5 @@ func init() { loggingStderr = true loggingW = nil loggingLevel = PanicLevel + logger = &lumberjack.Logger{} } diff --git a/pkg/logging/logging_test.go b/pkg/logging/logging_test.go index 48144daea..16391bdda 100644 --- a/pkg/logging/logging_test.go +++ b/pkg/logging/logging_test.go @@ -15,6 +15,8 @@ package logging import ( + testutils "gopkg.in/k8snetworkplumbingwg/multus-cni.v3/pkg/testing" + "gopkg.in/natefinch/lumberjack.v2" "testing" . "github.com/onsi/ginkgo" @@ -79,4 +81,54 @@ var _ = Describe("logging operations", func() { currentLevel := loggingLevel Expect(currentLevel).To(Equal(GetLoggingLevel())) }) + + It("Check user settings logOptions for logging", func() { + SetLogFile("/var/log/multus.log") + expectLogger := &lumberjack.Logger{ + Filename: "/var/log/multus.log", + MaxAge: 1, + MaxSize: 10, + MaxBackups: 1, + Compress: true, + } + logOptions := &LogOptions{ + MaxAge: testutils.Int(1), + MaxSize: testutils.Int(10), + MaxBackups: testutils.Int(1), + Compress: testutils.Bool(true), + } + SetLogOptions(logOptions) + Expect(expectLogger).To(Equal(logger)) + }) + + It("Check user settings logOptions and missing some options", func() { + SetLogFile("/var/log/multus.log") + expectLogger := &lumberjack.Logger{ + Filename: "/var/log/multus.log", + MaxAge: 5, + MaxSize: 100, + MaxBackups: 1, + Compress: true, + } + logOptions := &LogOptions{ + MaxBackups: testutils.Int(1), + Compress: testutils.Bool(true), + } + SetLogOptions(logOptions) + Expect(expectLogger).To(Equal(logger)) + }) + + It("Check user don't settings logOptions for logging", func() { + SetLogFile("/var/log/multus.log") + logger1 := &lumberjack.Logger{ + Filename: "/var/log/multus.log", + MaxAge: 5, + MaxSize: 100, + MaxBackups: 5, + Compress: true, + } + SetLogOptions(nil) + Expect(logger1).To(Equal(logger)) + }) + }) diff --git a/pkg/testing/testing.go b/pkg/testing/testing.go index 44d203d32..9471b144a 100644 --- a/pkg/testing/testing.go +++ b/pkg/testing/testing.go @@ -166,3 +166,13 @@ func (r *Result) String() string { } return fmt.Sprintf("%sDNS:%+v", str, r.DNS) } + +// Int returns a pointer to an int +func Int(i int) *int { + return &i +} + +// Bool returns a pointer to a bool. +func Bool(b bool) *bool { + return &b +} diff --git a/pkg/types/conf.go b/pkg/types/conf.go index 82bbeddbd..f6d66c51f 100644 --- a/pkg/types/conf.go +++ b/pkg/types/conf.go @@ -297,6 +297,7 @@ func LoadNetConf(bytes []byte) (*NetConf, error) { // Logging logging.SetLogStderr(netconf.LogToStderr) + logging.SetLogOptions(netconf.LogOptions) if netconf.LogFile != "" { logging.SetLogFile(netconf.LogFile) } diff --git a/pkg/types/conf_test.go b/pkg/types/conf_test.go index 591e422cc..b155ef7eb 100644 --- a/pkg/types/conf_test.go +++ b/pkg/types/conf_test.go @@ -112,27 +112,54 @@ var _ = Describe("config operations", func() { It("checks if logFile and logLevel are set correctly", func() { conf := `{ - "name": "node-cni-network", - "type": "multus", - "logLevel": "debug", - "logFile": "/var/log/multus.log", - "kubeconfig": "/etc/kubernetes/node-kubeconfig.yaml", - "delegates": [{ - "type": "weave-net" - }], - "runtimeConfig": { - "portMappings": [ - {"hostPort": 8080, "containerPort": 80, "protocol": "tcp"} - ] - } - - }` + "name": "node-cni-network", + "type": "multus", + "logLevel": "debug", + "logFile": "/var/log/multus.log", + "kubeconfig": "/etc/kubernetes/node-kubeconfig.yaml", + "delegates": [{ + "type": "weave-net" + }], + "runtimeConfig": { + "portMappings": [ + {"hostPort": 8080, "containerPort": 80, "protocol": "tcp"} + ] + } +}` netConf, err := LoadNetConf([]byte(conf)) Expect(err).NotTo(HaveOccurred()) Expect(netConf.LogLevel).To(Equal("debug")) Expect(netConf.LogFile).To(Equal("/var/log/multus.log")) }) + It("checks if logOptions are set correctly", func() { + conf := `{ + "name": "node-cni-network", + "type": "multus", + "logOptions": { + "maxAge": 5, + "maxSize": 100, + "maxBackups": 5, + "compress": true + }, + "kubeconfig": "/etc/kubernetes/node-kubeconfig.yaml", + "delegates": [{ + "type": "weave-net" + }], + "runtimeConfig": { + "portMappings": [ + {"hostPort": 8080, "containerPort": 80, "protocol": "tcp"} + ] + } +}` + netConf, err := LoadNetConf([]byte(conf)) + Expect(err).NotTo(HaveOccurred()) + Expect(*netConf.LogOptions.MaxAge).To(Equal(5)) + Expect(*netConf.LogOptions.MaxBackups).To(Equal(5)) + Expect(*netConf.LogOptions.MaxSize).To(Equal(100)) + Expect(*netConf.LogOptions.Compress).To(Equal(true)) + }) + It("properly sets namespace isolation using the default namespace", func() { conf := `{ "name": "node-cni-network", diff --git a/pkg/types/types.go b/pkg/types/types.go index c6d3d5096..814305be6 100644 --- a/pkg/types/types.go +++ b/pkg/types/types.go @@ -16,6 +16,7 @@ package types import ( + "gopkg.in/k8snetworkplumbingwg/multus-cni.v3/pkg/logging" "net" "github.com/containernetworking/cni/pkg/types" @@ -44,6 +45,7 @@ type NetConf struct { LogFile string `json:"logFile"` LogLevel string `json:"logLevel"` LogToStderr bool `json:"logToStderr,omitempty"` + LogOptions *logging.LogOptions `json:"logOptions,omitempty"` RuntimeConfig *RuntimeConfig `json:"runtimeConfig,omitempty"` // Default network readiness options ReadinessIndicatorFile string `json:"readinessindicatorfile"`