Fix review comments and new changes in config (#8515)

- Migrate and save only settings which are enabled
- Rename logger_http to logger_webhook and
  logger_http_audit to audit_webhook
- No more pretty printing comments, comment
  is a key=value pair now.
- Avoid quotes on values which do not have space in them
- `state="on"` is implicit for all SetConfigKV unless
  specified explicitly as `state="off"`
- Disabled IAM users should be disabled always

cmd/config/cache/legacy.go

@@ -25,16 +25,15 @@ import (
 
 // SetCacheConfig - One time migration code needed, for migrating from older config to new for Cache.
 func SetCacheConfig(s config.Config, cfg Config) {
+	if len(cfg.Drives) == 0 {
+		// Do not save cache if no settings available.
+		return
+	}
 	s[config.CacheSubSys][config.Default] = DefaultKVS
 	s[config.CacheSubSys][config.Default][Drives] = strings.Join(cfg.Drives, cacheDelimiter)
 	s[config.CacheSubSys][config.Default][Exclude] = strings.Join(cfg.Exclude, cacheDelimiter)
 	s[config.CacheSubSys][config.Default][Expiry] = fmt.Sprintf("%d", cfg.Expiry)
 	s[config.CacheSubSys][config.Default][Quota] = fmt.Sprintf("%d", cfg.MaxUse)
-	s[config.CacheSubSys][config.Default][config.State] = func() string {
-		if len(cfg.Drives) > 0 {
-			return config.StateOn
-		}
-		return config.StateOff
-	}()
+	s[config.CacheSubSys][config.Default][config.State] = config.StateOn
 	s[config.CacheSubSys][config.Default][config.Comment] = "Settings for Cache, after migrating config"
 }

cmd/config/cache/lookup.go

@@ -73,6 +73,10 @@ func LookupConfig(kvs config.KVS) (Config, error) {
 	// Check if cache is explicitly disabled
 	stateBool, err := config.ParseBool(env.Get(EnvCacheState, kvs.Get(config.State)))
 	if err != nil {
+		// Parsing failures happen due to empty KVS, ignore it.
+		if kvs.Empty() {
+			return cfg, nil
+		}
 		return cfg, err
 	}
 

cmd/config/compress/compress.go

@@ -83,6 +83,10 @@ func LookupConfig(kvs config.KVS) (Config, error) {
 	}
 	cfg.Enabled, err = config.ParseBool(compress)
 	if err != nil {
+		// Parsing failures happen due to empty KVS, ignore it.
+		if kvs.Empty() {
+			return cfg, nil
+		}
 		return cfg, err
 	}
 	if !cfg.Enabled {

cmd/config/compress/legacy.go

@@ -30,13 +30,12 @@ const (
 
 // SetCompressionConfig - One time migration code needed, for migrating from older config to new for Compression.
 func SetCompressionConfig(s config.Config, cfg Config) {
+	if !cfg.Enabled {
+		// No need to save disabled settings in new config.
+		return
+	}
 	s[config.CompressionSubSys][config.Default] = config.KVS{
-		config.State: func() string {
-			if cfg.Enabled {
-				return config.StateOn
-			}
-			return config.StateOff
-		}(),
+		config.State:   config.StateOn,
 		config.Comment: "Settings for Compression, after migrating config",
 		Extensions:     strings.Join(cfg.Extensions, config.ValueSeparator),
 		MimeTypes:      strings.Join(cfg.MimeTypes, config.ValueSeparator),

cmd/config/config.go

@@ -57,19 +57,19 @@ const (
 
 // Top level config constants.
 const (
-	CredentialsSubSys     = "credentials"
-	PolicyOPASubSys       = "policy_opa"
-	IdentityOpenIDSubSys  = "identity_openid"
-	IdentityLDAPSubSys    = "identity_ldap"
-	WormSubSys            = "worm"
-	CacheSubSys           = "cache"
-	RegionSubSys          = "region"
-	EtcdSubSys            = "etcd"
-	StorageClassSubSys    = "storageclass"
-	CompressionSubSys     = "compression"
-	KmsVaultSubSys        = "kms_vault"
-	LoggerHTTPSubSys      = "logger_http"
-	LoggerHTTPAuditSubSys = "logger_http_audit"
+	CredentialsSubSys    = "credentials"
+	PolicyOPASubSys      = "policy_opa"
+	IdentityOpenIDSubSys = "identity_openid"
+	IdentityLDAPSubSys   = "identity_ldap"
+	WormSubSys           = "worm"
+	CacheSubSys          = "cache"
+	RegionSubSys         = "region"
+	EtcdSubSys           = "etcd"
+	StorageClassSubSys   = "storageclass"
+	CompressionSubSys    = "compression"
+	KmsVaultSubSys       = "kms_vault"
+	LoggerWebhookSubSys  = "logger_webhook"
+	AuditWebhookSubSys   = "audit_webhook"
 
 	// Add new constants here if you add new fields to config.
 )
@@ -100,8 +100,8 @@ var SubSystems = set.CreateStringSet([]string{
 	StorageClassSubSys,
 	CompressionSubSys,
 	KmsVaultSubSys,
-	LoggerHTTPSubSys,
-	LoggerHTTPAuditSubSys,
+	LoggerWebhookSubSys,
+	AuditWebhookSubSys,
 	PolicyOPASubSys,
 	IdentityLDAPSubSys,
 	IdentityOpenIDSubSys,
@@ -137,7 +137,7 @@ const (
 	SubSystemSeparator = madmin.SubSystemSeparator
 	KvSeparator        = madmin.KvSeparator
 	KvSpaceSeparator   = madmin.KvSpaceSeparator
-	KvComment          = madmin.KvComment
+	KvComment          = `#`
 	KvNewline          = madmin.KvNewline
 	KvDoubleQuote      = madmin.KvDoubleQuote
 	KvSingleQuote      = madmin.KvSingleQuote
@@ -151,9 +151,18 @@ const (
 // to operate on list of key values.
 type KVS map[string]string
 
+// Empty - return if kv is empty
+func (kvs KVS) Empty() bool {
+	return len(kvs) == 0
+}
+
 func (kvs KVS) String() string {
 	var s strings.Builder
 	for k, v := range kvs {
+		// Do not need to print if state is on
+		if k == State && v == StateOn {
+			continue
+		}
 		s.WriteString(k)
 		s.WriteString(KvSeparator)
 		s.WriteString(KvDoubleQuote)
@@ -215,8 +224,13 @@ func LookupCreds(kv KVS) (auth.Credentials, error) {
 	if err := CheckValidKeys(CredentialsSubSys, kv, DefaultCredentialKVS); err != nil {
 		return auth.Credentials{}, err
 	}
-	return auth.CreateCredentials(env.Get(EnvAccessKey, kv.Get(AccessKey)),
-		env.Get(EnvSecretKey, kv.Get(SecretKey)))
+	accessKey := env.Get(EnvAccessKey, kv.Get(AccessKey))
+	secretKey := env.Get(EnvSecretKey, kv.Get(SecretKey))
+	if accessKey == "" && secretKey == "" {
+		accessKey = auth.DefaultAccessKey
+		secretKey = auth.DefaultSecretKey
+	}
+	return auth.CreateCredentials(accessKey, secretKey)
 }
 
 // LookupRegion - get current region.
@@ -348,7 +362,8 @@ func (c Config) DelKVS(s string) error {
 		delete(c[subSystemValue[0]], subSystemValue[1])
 		return nil
 	}
-	return Error(fmt.Sprintf("default config for '%s' sub-system cannot be removed", s))
+	delete(c[subSystemValue[0]], Default)
+	return nil
 }
 
 // This function is needed, to trim off single or double quotes, creeping into the values.
@@ -373,7 +388,7 @@ func (c Config) Clone() Config {
 }
 
 // SetKVS - set specific key values per sub-system.
-func (c Config) SetKVS(s string, defaultKVS map[string]KVS) error {
+func (c Config) SetKVS(s string) error {
 	if len(s) == 0 {
 		return Error("input arguments cannot be empty")
 	}
@@ -418,9 +433,7 @@ func (c Config) SetKVS(s string, defaultKVS map[string]KVS) error {
 	}
 	_, ok := c[subSystemValue[0]][tgt]
 	if !ok {
-		c[subSystemValue[0]][tgt] = defaultKVS[subSystemValue[0]]
-		comment := fmt.Sprintf("Settings for sub-system target %s:%s", subSystemValue[0], tgt)
-		c[subSystemValue[0]][tgt][Comment] = comment
+		c[subSystemValue[0]][tgt] = KVS{}
 	}
 
 	for k, v := range kvs {

cmd/config/etcd/etcd.go

@@ -129,9 +129,9 @@ func lookupLegacyConfig(rootCAs *x509.CertPool) (Config, error) {
 }
 
 // LookupConfig - Initialize new etcd config.
-func LookupConfig(kv config.KVS, rootCAs *x509.CertPool) (Config, error) {
+func LookupConfig(kvs config.KVS, rootCAs *x509.CertPool) (Config, error) {
 	cfg := Config{}
-	if err := config.CheckValidKeys(config.EtcdSubSys, kv, DefaultKVS); err != nil {
+	if err := config.CheckValidKeys(config.EtcdSubSys, kvs, DefaultKVS); err != nil {
 		return cfg, err
 	}
 
@@ -152,8 +152,11 @@ func LookupConfig(kv config.KVS, rootCAs *x509.CertPool) (Config, error) {
 		}
 	}
 
-	stateBool, err = config.ParseBool(env.Get(EnvEtcdState, kv.Get(config.State)))
+	stateBool, err = config.ParseBool(env.Get(EnvEtcdState, kvs.Get(config.State)))
 	if err != nil {
+		if kvs.Empty() {
+			return cfg, nil
+		}
 		return cfg, err
 	}
 
@@ -161,7 +164,7 @@ func LookupConfig(kv config.KVS, rootCAs *x509.CertPool) (Config, error) {
 		return cfg, nil
 	}
 
-	endpoints := env.Get(EnvEtcdEndpoints, kv.Get(Endpoints))
+	endpoints := env.Get(EnvEtcdEndpoints, kvs.Get(Endpoints))
 	if endpoints == "" {
 		return cfg, config.Error("'endpoints' key cannot be empty to enable etcd")
 	}
@@ -175,15 +178,15 @@ func LookupConfig(kv config.KVS, rootCAs *x509.CertPool) (Config, error) {
 	cfg.DialTimeout = defaultDialTimeout
 	cfg.DialKeepAliveTime = defaultDialKeepAlive
 	cfg.Endpoints = etcdEndpoints
-	cfg.CoreDNSPath = env.Get(EnvEtcdCoreDNSPath, kv.Get(CoreDNSPath))
+	cfg.CoreDNSPath = env.Get(EnvEtcdCoreDNSPath, kvs.Get(CoreDNSPath))
 	if etcdSecure {
 		cfg.TLS = &tls.Config{
 			RootCAs: rootCAs,
 		}
 		// This is only to support client side certificate authentication
 		// https://coreos.com/etcd/docs/latest/op-guide/security.html
-		etcdClientCertFile := env.Get(EnvEtcdClientCert, kv.Get(ClientCert))
-		etcdClientCertKey := env.Get(EnvEtcdClientCertKey, kv.Get(ClientCertKey))
+		etcdClientCertFile := env.Get(EnvEtcdClientCert, kvs.Get(ClientCert))
+		etcdClientCertKey := env.Get(EnvEtcdClientCertKey, kvs.Get(ClientCertKey))
 		if etcdClientCertFile != "" && etcdClientCertKey != "" {
 			cfg.TLS.GetClientCertificate = func(unused *tls.CertificateRequestInfo) (*tls.Certificate, error) {
 				cert, err := tls.LoadX509KeyPair(etcdClientCertFile, etcdClientCertKey)

cmd/config/identity/ldap/config.go

@@ -115,6 +115,9 @@ func Lookup(kvs config.KVS, rootCAs *x509.CertPool) (l Config, err error) {
 	}
 	stateBool, err := config.ParseBool(env.Get(EnvLDAPState, kvs.Get(config.State)))
 	if err != nil {
+		if kvs.Empty() {
+			return l, nil
+		}
 		return l, err
 	}
 	ldapServer := env.Get(EnvServerAddr, kvs.Get(ServerAddr))

cmd/config/identity/ldap/legacy.go

@@ -20,13 +20,12 @@ import "github.com/minio/minio/cmd/config"
 
 // SetIdentityLDAP - One time migration code needed, for migrating from older config to new for LDAPConfig.
 func SetIdentityLDAP(s config.Config, ldapArgs Config) {
+	if !ldapArgs.Enabled {
+		// ldap not enabled no need to preserve it in new settings.
+		return
+	}
 	s[config.IdentityLDAPSubSys][config.Default] = config.KVS{
-		config.State: func() string {
-			if !ldapArgs.Enabled {
-				return config.StateOff
-			}
-			return config.StateOn
-		}(),
+		config.State:       config.StateOn,
 		config.Comment:     "Settings for LDAP, after migrating config",
 		ServerAddr:         ldapArgs.ServerAddr,
 		STSExpiry:          ldapArgs.STSExpiryDuration,

cmd/config/identity/openid/jwt.go

@@ -267,29 +267,32 @@ var (
 )
 
 // LookupConfig lookup jwks from config, override with any ENVs.
-func LookupConfig(kv config.KVS, transport *http.Transport, closeRespFn func(io.ReadCloser)) (c Config, err error) {
-	if err = config.CheckValidKeys(config.IdentityOpenIDSubSys, kv, DefaultKVS); err != nil {
+func LookupConfig(kvs config.KVS, transport *http.Transport, closeRespFn func(io.ReadCloser)) (c Config, err error) {
+	if err = config.CheckValidKeys(config.IdentityOpenIDSubSys, kvs, DefaultKVS); err != nil {
 		return c, err
 	}
 
-	stateBool, err := config.ParseBool(env.Get(EnvIdentityOpenIDState, kv.Get(config.State)))
+	stateBool, err := config.ParseBool(env.Get(EnvIdentityOpenIDState, kvs.Get(config.State)))
 	if err != nil {
+		if kvs.Empty() {
+			return c, nil
+		}
 		return c, err
 	}
 
 	jwksURL := env.Get(EnvIamJwksURL, "") // Legacy
 	if jwksURL == "" {
-		jwksURL = env.Get(EnvIdentityOpenIDJWKSURL, kv.Get(JwksURL))
+		jwksURL = env.Get(EnvIdentityOpenIDJWKSURL, kvs.Get(JwksURL))
 	}
 
 	c = Config{
-		ClaimPrefix: env.Get(EnvIdentityOpenIDClaimPrefix, kv.Get(ClaimPrefix)),
+		ClaimPrefix: env.Get(EnvIdentityOpenIDClaimPrefix, kvs.Get(ClaimPrefix)),
 		publicKeys:  make(map[string]crypto.PublicKey),
 		transport:   transport,
 		closeRespFn: closeRespFn,
 	}
 
-	configURL := env.Get(EnvIdentityOpenIDURL, kv.Get(ConfigURL))
+	configURL := env.Get(EnvIdentityOpenIDURL, kvs.Get(ConfigURL))
 	if configURL != "" {
 		c.URL, err = xnet.ParseHTTPURL(configURL)
 		if err != nil {

cmd/config/identity/openid/legacy.go

@@ -25,24 +25,15 @@ const (
 
 // SetIdentityOpenID - One time migration code needed, for migrating from older config to new for OpenIDConfig.
 func SetIdentityOpenID(s config.Config, cfg Config) {
+	if cfg.JWKS.URL == nil || cfg.JWKS.URL.String() == "" {
+		// No need to save not-enabled settings in new config.
+		return
+	}
 	s[config.IdentityOpenIDSubSys][config.Default] = config.KVS{
-		config.State: func() string {
-			if cfg.JWKS.URL == nil {
-				return config.StateOff
-			}
-			if cfg.JWKS.URL.String() == "" {
-				return config.StateOff
-			}
-			return config.StateOn
-		}(),
+		config.State:   config.StateOn,
 		config.Comment: "Settings for OpenID, after migrating config",
-		JwksURL: func() string {
-			if cfg.JWKS.URL != nil {
-				return cfg.JWKS.URL.String()
-			}
-			return ""
-		}(),
-		ConfigURL:   "",
-		ClaimPrefix: "",
+		JwksURL:        cfg.JWKS.URL.String(),
+		ConfigURL:      "",
+		ClaimPrefix:    "",
 	}
 }

cmd/config/legacy.go

@@ -42,14 +42,13 @@ func SetRegion(c Config, name string) {
 
 // SetWorm - One time migration code needed, for migrating from older config to new for Worm mode.
 func SetWorm(c Config, b bool) {
+	if !b {
+		// We don't save disabled configs
+		return
+	}
 	// Set the new value.
 	c[WormSubSys][Default] = KVS{
-		State: func() string {
-			if b {
-				return StateOn
-			}
-			return StateOff
-		}(),
+		State:   StateOn,
 		Comment: "Settings for WORM, after migrating config",
 	}
 }

cmd/config/notify/help.go

@@ -48,8 +48,8 @@ var (
 		target.KafkaSASLUsername:  "Username for SASL/PLAIN  or SASL/SCRAM authentication",
 		target.KafkaSASLPassword:  "Password for SASL/PLAIN  or SASL/SCRAM authentication",
 		target.KafkaTLSClientAuth: "ClientAuth determines the Kafka server's policy for TLS client auth",
-		target.KafkaSASLEnable:    "Set this to 'on' to enable SASL authentication",
-		target.KafkaTLSEnable:     "Set this to 'on' to enable TLS",
+		target.KafkaSASL:          "Set this to 'on' to enable SASL authentication",
+		target.KafkaTLS:           "Set this to 'on' to enable TLS",
 		target.KafkaTLSSkipVerify: "Set this to 'on' to disable client verification of server certificate chain",
 		target.KafkaQueueLimit:    "Enable persistent event store queue limit, defaults to '10000'",
 		target.KafkaQueueDir:      "Local directory where events are stored eg: '/home/events'",
@@ -139,7 +139,7 @@ var (
 		target.NATSToken:                       "Token to be used when connecting to a server",
 		target.NATSSecure:                      "Set this to 'on', enables TLS secure connections that skip server verification (not recommended)",
 		target.NATSPingInterval:                "Client ping commands interval to the server, disabled by default",
-		target.NATSStreamingEnable:             "Set this to 'on', to use streaming NATS server",
+		target.NATSStreaming:                   "Set this to 'on', to use streaming NATS server",
 		target.NATSStreamingAsync:              "Set this to 'on', to enable asynchronous publish, process the ACK or error state",
 		target.NATSStreamingMaxPubAcksInFlight: "Specifies how many messages can be published without getting ACKs back from NATS streaming server",
 		target.NATSStreamingClusterID:          "Unique ID for the NATS streaming cluster",
@@ -152,7 +152,7 @@ var (
 		config.Comment:          "A comment to describe the NSQ target setting",
 		target.NSQAddress:       "NSQ server address eg: '127.0.0.1:4150'",
 		target.NSQTopic:         "NSQ topic unique per target",
-		target.NSQTLSEnable:     "Set this to 'on', to enable TLS negotiation",
+		target.NSQTLS:           "Set this to 'on', to enable TLS negotiation",
 		target.NSQTLSSkipVerify: "Set this to 'on', to disable client verification of server certificates",
 		target.NSQQueueLimit:    "Enable persistent event store queue limit, defaults to '10000'",
 		target.NSQQueueDir:      "Local directory where events are stored eg: '/home/events'",

cmd/config/notify/legacy.go

@@ -11,17 +11,16 @@ import (
 
 // SetNotifyKafka - helper for config migration from older config.
 func SetNotifyKafka(s config.Config, kName string, cfg target.KafkaArgs) error {
+	if !cfg.Enable {
+		return nil
+	}
+
 	if err := cfg.Validate(); err != nil {
 		return err
 	}
 
 	s[config.NotifyKafkaSubSys][kName] = config.KVS{
-		config.State: func() string {
-			if cfg.Enable {
-				return config.StateOn
-			}
-			return config.StateOff
-		}(),
+		config.State: config.StateOn,
 		target.KafkaBrokers: func() string {
 			var brokers []string
 			for _, broker := range cfg.Brokers {
@@ -33,10 +32,10 @@ func SetNotifyKafka(s config.Config, kName string, cfg target.KafkaArgs) error {
 		target.KafkaTopic:         cfg.Topic,
 		target.KafkaQueueDir:      cfg.QueueDir,
 		target.KafkaQueueLimit:    strconv.Itoa(int(cfg.QueueLimit)),
-		target.KafkaTLSEnable:     config.FormatBool(cfg.TLS.Enable),
+		target.KafkaTLS:           config.FormatBool(cfg.TLS.Enable),
 		target.KafkaTLSSkipVerify: config.FormatBool(cfg.TLS.SkipVerify),
 		target.KafkaTLSClientAuth: strconv.Itoa(int(cfg.TLS.ClientAuth)),
-		target.KafkaSASLEnable:    config.FormatBool(cfg.SASL.Enable),
+		target.KafkaSASL:          config.FormatBool(cfg.SASL.Enable),
 		target.KafkaSASLUsername:  cfg.SASL.User,
 		target.KafkaSASLPassword:  cfg.SASL.Password,
 	}
@@ -45,17 +44,16 @@ func SetNotifyKafka(s config.Config, kName string, cfg target.KafkaArgs) error {
 
 // SetNotifyAMQP - helper for config migration from older config.
 func SetNotifyAMQP(s config.Config, amqpName string, cfg target.AMQPArgs) error {
+	if !cfg.Enable {
+		return nil
+	}
+
 	if err := cfg.Validate(); err != nil {
 		return err
 	}
 
 	s[config.NotifyAMQPSubSys][amqpName] = config.KVS{
-		config.State: func() string {
-			if cfg.Enable {
-				return config.StateOn
-			}
-			return config.StateOff
-		}(),
+		config.State:            config.StateOn,
 		config.Comment:          "Settings for AMQP notification, after migrating config",
 		target.AmqpURL:          cfg.URL.String(),
 		target.AmqpExchange:     cfg.Exchange,
@@ -76,17 +74,16 @@ func SetNotifyAMQP(s config.Config, amqpName string, cfg target.AMQPArgs) error
 
 // SetNotifyES - helper for config migration from older config.
 func SetNotifyES(s config.Config, esName string, cfg target.ElasticsearchArgs) error {
+	if !cfg.Enable {
+		return nil
+	}
+
 	if err := cfg.Validate(); err != nil {
 		return err
 	}
 
 	s[config.NotifyESSubSys][esName] = config.KVS{
-		config.State: func() string {
-			if cfg.Enable {
-				return config.StateOn
-			}
-			return config.StateOff
-		}(),
+		config.State:             config.StateOn,
 		config.Comment:           "Settings for Elasticsearch notification, after migrating config",
 		target.ElasticFormat:     cfg.Format,
 		target.ElasticURL:        cfg.URL.String(),
@@ -100,17 +97,16 @@ func SetNotifyES(s config.Config, esName string, cfg target.ElasticsearchArgs) e
 
 // SetNotifyRedis - helper for config migration from older config.
 func SetNotifyRedis(s config.Config, redisName string, cfg target.RedisArgs) error {
+	if !cfg.Enable {
+		return nil
+	}
+
 	if err := cfg.Validate(); err != nil {
 		return err
 	}
 
 	s[config.NotifyRedisSubSys][redisName] = config.KVS{
-		config.State: func() string {
-			if cfg.Enable {
-				return config.StateOn
-			}
-			return config.StateOff
-		}(),
+		config.State:           config.StateOn,
 		config.Comment:         "Settings for Redis notification, after migrating config",
 		target.RedisFormat:     cfg.Format,
 		target.RedisAddress:    cfg.Addr.String(),
@@ -125,17 +121,16 @@ func SetNotifyRedis(s config.Config, redisName string, cfg target.RedisArgs) err
 
 // SetNotifyWebhook - helper for config migration from older config.
 func SetNotifyWebhook(s config.Config, whName string, cfg target.WebhookArgs) error {
+	if !cfg.Enable {
+		return nil
+	}
+
 	if err := cfg.Validate(); err != nil {
 		return err
 	}
 
 	s[config.NotifyWebhookSubSys][whName] = config.KVS{
-		config.State: func() string {
-			if cfg.Enable {
-				return config.StateOn
-			}
-			return config.StateOff
-		}(),
+		config.State:             config.StateOn,
 		config.Comment:           "Settings for Webhook notification, after migrating config",
 		target.WebhookEndpoint:   cfg.Endpoint.String(),
 		target.WebhookAuthToken:  cfg.AuthToken,
@@ -148,17 +143,16 @@ func SetNotifyWebhook(s config.Config, whName string, cfg target.WebhookArgs) er
 
 // SetNotifyPostgres - helper for config migration from older config.
 func SetNotifyPostgres(s config.Config, psqName string, cfg target.PostgreSQLArgs) error {
+	if !cfg.Enable {
+		return nil
+	}
+
 	if err := cfg.Validate(); err != nil {
 		return err
 	}
 
 	s[config.NotifyPostgresSubSys][psqName] = config.KVS{
-		config.State: func() string {
-			if cfg.Enable {
-				return config.StateOn
-			}
-			return config.StateOff
-		}(),
+		config.State:                    config.StateOn,
 		config.Comment:                  "Settings for Postgres notification, after migrating config",
 		target.PostgresFormat:           cfg.Format,
 		target.PostgresConnectionString: cfg.ConnectionString,
@@ -177,21 +171,20 @@ func SetNotifyPostgres(s config.Config, psqName string, cfg target.PostgreSQLArg
 
 // SetNotifyNSQ - helper for config migration from older config.
 func SetNotifyNSQ(s config.Config, nsqName string, cfg target.NSQArgs) error {
+	if !cfg.Enable {
+		return nil
+	}
+
 	if err := cfg.Validate(); err != nil {
 		return err
 	}
 
 	s[config.NotifyNSQSubSys][nsqName] = config.KVS{
-		config.State: func() string {
-			if cfg.Enable {
-				return config.StateOn
-			}
-			return config.StateOff
-		}(),
+		config.State:            config.StateOn,
 		config.Comment:          "Settings for NSQ notification, after migrating config",
 		target.NSQAddress:       cfg.NSQDAddress.String(),
 		target.NSQTopic:         cfg.Topic,
-		target.NSQTLSEnable:     config.FormatBool(cfg.TLS.Enable),
+		target.NSQTLS:           config.FormatBool(cfg.TLS.Enable),
 		target.NSQTLSSkipVerify: config.FormatBool(cfg.TLS.SkipVerify),
 		target.NSQQueueDir:      cfg.QueueDir,
 		target.NSQQueueLimit:    strconv.Itoa(int(cfg.QueueLimit)),
@@ -202,17 +195,16 @@ func SetNotifyNSQ(s config.Config, nsqName string, cfg target.NSQArgs) error {
 
 // SetNotifyNATS - helper for config migration from older config.
 func SetNotifyNATS(s config.Config, natsName string, cfg target.NATSArgs) error {
+	if !cfg.Enable {
+		return nil
+	}
+
 	if err := cfg.Validate(); err != nil {
 		return err
 	}
 
 	s[config.NotifyNATSSubSys][natsName] = config.KVS{
-		config.State: func() string {
-			if cfg.Enable {
-				return config.StateOn
-			}
-			return config.StateOff
-		}(),
+		config.State:            config.StateOn,
 		config.Comment:          "Settings for NATS notification, after migrating config",
 		target.NATSAddress:      cfg.Address.String(),
 		target.NATSSubject:      cfg.Subject,
@@ -223,7 +215,7 @@ func SetNotifyNATS(s config.Config, natsName string, cfg target.NATSArgs) error
 		target.NATSPingInterval: strconv.FormatInt(cfg.PingInterval, 10),
 		target.NATSQueueDir:     cfg.QueueDir,
 		target.NATSQueueLimit:   strconv.Itoa(int(cfg.QueueLimit)),
-		target.NATSStreamingEnable: func() string {
+		target.NATSStreaming: func() string {
 			if cfg.Streaming.Enable {
 				return config.StateOn
 			}
@@ -239,17 +231,16 @@ func SetNotifyNATS(s config.Config, natsName string, cfg target.NATSArgs) error
 
 // SetNotifyMySQL - helper for config migration from older config.
 func SetNotifyMySQL(s config.Config, sqlName string, cfg target.MySQLArgs) error {
+	if !cfg.Enable {
+		return nil
+	}
+
 	if err := cfg.Validate(); err != nil {
 		return err
 	}
 
 	s[config.NotifyMySQLSubSys][sqlName] = config.KVS{
-		config.State: func() string {
-			if cfg.Enable {
-				return config.StateOn
-			}
-			return config.StateOff
-		}(),
+		config.State:           config.StateOn,
 		config.Comment:         "Settings for MySQL notification, after migrating config",
 		target.MySQLFormat:     cfg.Format,
 		target.MySQLDSNString:  cfg.DSN,
@@ -268,17 +259,16 @@ func SetNotifyMySQL(s config.Config, sqlName string, cfg target.MySQLArgs) error
 
 // SetNotifyMQTT - helper for config migration from older config.
 func SetNotifyMQTT(s config.Config, mqttName string, cfg target.MQTTArgs) error {
+	if !cfg.Enable {
+		return nil
+	}
+
 	if err := cfg.Validate(); err != nil {
 		return err
 	}
 
 	s[config.NotifyMQTTSubSys][mqttName] = config.KVS{
-		config.State: func() string {
-			if cfg.Enable {
-				return config.StateOn
-			}
-			return config.StateOff
-		}(),
+		config.State:                 config.StateOn,
 		config.Comment:               "Settings for MQTT notification, after migrating config",
 		target.MqttBroker:            cfg.Broker.String(),
 		target.MqttTopic:             cfg.Topic,

cmd/config/notify/parse.go

@@ -347,8 +347,8 @@ var (
 		target.KafkaSASLUsername:  "",
 		target.KafkaSASLPassword:  "",
 		target.KafkaTLSClientAuth: "0",
-		target.KafkaSASLEnable:    config.StateOff,
-		target.KafkaTLSEnable:     config.StateOff,
+		target.KafkaSASL:          config.StateOff,
+		target.KafkaTLS:           config.StateOff,
 		target.KafkaTLSSkipVerify: config.StateOff,
 		target.KafkaQueueLimit:    "0",
 		target.KafkaQueueDir:      "",
@@ -427,7 +427,7 @@ func GetNotifyKafka(kafkaKVS map[string]config.KVS) (map[string]target.KafkaArgs
 			QueueLimit: queueLimit,
 		}
 
-		tlsEnableEnv := target.EnvKafkaTLSEnable
+		tlsEnableEnv := target.EnvKafkaTLS
 		if k != config.Default {
 			tlsEnableEnv = tlsEnableEnv + config.Default + k
 		}
@@ -435,7 +435,7 @@ func GetNotifyKafka(kafkaKVS map[string]config.KVS) (map[string]target.KafkaArgs
 		if k != config.Default {
 			tlsSkipVerifyEnv = tlsSkipVerifyEnv + config.Default + k
 		}
-		kafkaArgs.TLS.Enable = env.Get(tlsEnableEnv, kv.Get(target.KafkaTLSEnable)) == config.StateOn
+		kafkaArgs.TLS.Enable = env.Get(tlsEnableEnv, kv.Get(target.KafkaTLS)) == config.StateOn
 		kafkaArgs.TLS.SkipVerify = env.Get(tlsSkipVerifyEnv, kv.Get(target.KafkaTLSSkipVerify)) == config.StateOn
 		kafkaArgs.TLS.ClientAuth = tls.ClientAuthType(clientAuth)
 
@@ -451,7 +451,7 @@ func GetNotifyKafka(kafkaKVS map[string]config.KVS) (map[string]target.KafkaArgs
 		if k != config.Default {
 			saslPasswordEnv = saslPasswordEnv + config.Default + k
 		}
-		kafkaArgs.SASL.Enable = env.Get(saslEnableEnv, kv.Get(target.KafkaSASLEnable)) == config.StateOn
+		kafkaArgs.SASL.Enable = env.Get(saslEnableEnv, kv.Get(target.KafkaSASL)) == config.StateOn
 		kafkaArgs.SASL.User = env.Get(saslUsernameEnv, kv.Get(target.KafkaSASLUsername))
 		kafkaArgs.SASL.Password = env.Get(saslPasswordEnv, kv.Get(target.KafkaSASLPassword))
 
@@ -711,7 +711,7 @@ var (
 		target.NATSPingInterval:                "0",
 		target.NATSQueueLimit:                  "0",
 		target.NATSQueueDir:                    "",
-		target.NATSStreamingEnable:             config.StateOff,
+		target.NATSStreaming:                   config.StateOff,
 		target.NATSStreamingAsync:              config.StateOff,
 		target.NATSStreamingMaxPubAcksInFlight: "0",
 		target.NATSStreamingClusterID:          "",
@@ -808,12 +808,12 @@ func GetNotifyNATS(natsKVS map[string]config.KVS) (map[string]target.NATSArgs, e
 			QueueLimit:   queueLimit,
 		}
 
-		streamingEnableEnv := target.EnvNATSStreamingEnable
+		streamingEnableEnv := target.EnvNATSStreaming
 		if k != config.Default {
 			streamingEnableEnv = streamingEnableEnv + config.Default + k
 		}
 
-		streamingEnabled := env.Get(streamingEnableEnv, kv.Get(target.NATSStreamingEnable)) == config.StateOn
+		streamingEnabled := env.Get(streamingEnableEnv, kv.Get(target.NATSStreaming)) == config.StateOn
 		if streamingEnabled {
 			asyncEnv := target.EnvNATSStreamingAsync
 			if k != config.Default {
@@ -854,7 +854,7 @@ var (
 		config.Comment:          "Default settings for NSQ notification",
 		target.NSQAddress:       "",
 		target.NSQTopic:         "",
-		target.NSQTLSEnable:     config.StateOff,
+		target.NSQTLS:           config.StateOff,
 		target.NSQTLSSkipVerify: config.StateOff,
 		target.NSQQueueLimit:    "0",
 		target.NSQQueueDir:      "",
@@ -886,7 +886,7 @@ func GetNotifyNSQ(nsqKVS map[string]config.KVS) (map[string]target.NSQArgs, erro
 		if err != nil {
 			return nil, err
 		}
-		tlsEnableEnv := target.EnvNSQTLSEnable
+		tlsEnableEnv := target.EnvNSQTLS
 		if k != config.Default {
 			tlsEnableEnv = tlsEnableEnv + config.Default + k
 		}
@@ -920,7 +920,7 @@ func GetNotifyNSQ(nsqKVS map[string]config.KVS) (map[string]target.NSQArgs, erro
 			QueueDir:    env.Get(queueDirEnv, kv.Get(target.NSQQueueDir)),
 			QueueLimit:  queueLimit,
 		}
-		nsqArgs.TLS.Enable = env.Get(tlsEnableEnv, kv.Get(target.NSQTLSEnable)) == config.StateOn
+		nsqArgs.TLS.Enable = env.Get(tlsEnableEnv, kv.Get(target.NSQTLS)) == config.StateOn
 		nsqArgs.TLS.SkipVerify = env.Get(tlsSkipVerifyEnv, kv.Get(target.NSQTLSSkipVerify)) == config.StateOn
 
 		if err = nsqArgs.Validate(); err != nil {

cmd/config/policy/opa/legacy.go

@@ -28,23 +28,14 @@ const (
 
 // SetPolicyOPAConfig - One time migration code needed, for migrating from older config to new for PolicyOPAConfig.
 func SetPolicyOPAConfig(s config.Config, opaArgs Args) {
+	if opaArgs.URL == nil || opaArgs.URL.String() == "" {
+		// Do not enable if opaArgs was empty.
+		return
+	}
 	s[config.PolicyOPASubSys][config.Default] = config.KVS{
-		config.State: func() string {
-			if opaArgs.URL == nil {
-				return config.StateOff
-			}
-			if opaArgs.URL.String() == "" {
-				return config.StateOff
-			}
-			return config.StateOn
-		}(),
+		config.State:   config.StateOn,
 		config.Comment: "Settings for OPA, after migrating config",
-		URL: func() string {
-			if opaArgs.URL != nil {
-				return opaArgs.URL.String()
-			}
-			return ""
-		}(),
-		AuthToken: opaArgs.AuthToken,
+		URL:            opaArgs.URL.String(),
+		AuthToken:      opaArgs.AuthToken,
 	}
 }

cmd/config/storageclass/legacy.go

@@ -22,15 +22,14 @@ import (
 
 // SetStorageClass - One time migration code needed, for migrating from older config to new for StorageClass.
 func SetStorageClass(s config.Config, cfg Config) {
+	if len(cfg.Standard.String()) == 0 && len(cfg.RRS.String()) == 0 {
+		// Do not enable storage-class if no settings found.
+		return
+	}
 	s[config.StorageClassSubSys][config.Default] = config.KVS{
-		ClassStandard: cfg.Standard.String(),
-		ClassRRS:      cfg.RRS.String(),
-		config.State: func() string {
-			if len(cfg.Standard.String()) > 0 || len(cfg.RRS.String()) > 0 {
-				return config.StateOn
-			}
-			return config.StateOff
-		}(),
+		ClassStandard:  cfg.Standard.String(),
+		ClassRRS:       cfg.RRS.String(),
+		config.State:   config.StateOn,
 		config.Comment: "Settings for StorageClass, after migrating config",
 	}
 }

cmd/config/storageclass/storage-class.go

@@ -222,6 +222,9 @@ func LookupConfig(kvs config.KVS, drivesPerSet int) (cfg Config, err error) {
 
 	stateBool, err := config.ParseBool(env.Get(EnvStorageClass, kvs.Get(config.State)))
 	if err != nil {
+		if kvs.Empty() {
+			return cfg, nil
+		}
 		return cfg, err
 	}
 	ssc := env.Get(StandardEnv, kvs.Get(ClassStandard))