add some flags for customize the log settings (#817)

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)

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. 

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 {

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(

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{}
 }

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))
+	})
+
 })

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
+}

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)
 	}

pkg/types/conf_test.go

@@ -125,14 +125,41 @@ var _ = Describe("config operations", func() {
 			{"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",

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"`