Fix compilation errors and tests after making opts of type struct

cmd/cgr-loader/flags_test.go

@@ -18,7 +18,10 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>
 
 package main
 
-import "testing"
+import (
+	"testing"
+	"time"
+)
 
 func TestCGRLoaderFlags(t *testing.T) {
 	if err := cgrLoaderFlags.Parse([]string{"-config_path", "/etc/cgrates"}); err != nil {
@@ -83,19 +86,19 @@ func TestCGRLoaderFlags(t *testing.T) {
 
 	if err := cgrLoaderFlags.Parse([]string{"-redisClusterSync", "3s"}); err != nil {
 		t.Error(err)
-	} else if *dbRedisClusterSync != "3s" {
+	} else if *dbRedisClusterSync != 3*time.Second {
 		t.Errorf("Expected 3s, received %+v", *dbRedisClusterSync)
 	}
 
 	if err := cgrLoaderFlags.Parse([]string{"-redisClusterOndownDelay", "0"}); err != nil {
 		t.Error(err)
-	} else if *dbRedisClusterDownDelay != "0" {
+	} else if *dbRedisClusterDownDelay != 0 {
 		t.Errorf("Expected 0, received %+v", *dbRedisClusterDownDelay)
 	}
 
 	if err := cgrLoaderFlags.Parse([]string{"-mongoQueryTimeout", "5s"}); err != nil {
 		t.Error(err)
-	} else if *dbQueryTimeout != "5s" {
+	} else if *dbQueryTimeout != 5*time.Second {
 		t.Errorf("Expected 5s, received %+v", *dbQueryTimeout)
 	}
 

cmd/cgr-migrator/cgr-migrator.go

@@ -267,11 +267,11 @@ func main() {
 		mgrCfg.MigratorCgrCfg().OutDataDBEncoding = *outDBDataEncoding
 	}
 	if *outDataDBRedisSentinel == utils.MetaDataDB {
-		if utils.IfaceAsString(dfltCfg.MigratorCgrCfg().OutDataDBOpts[utils.RedisSentinelNameCfg]) == utils.IfaceAsString(mgrCfg.MigratorCgrCfg().OutDataDBOpts[utils.RedisSentinelNameCfg]) {
-			mgrCfg.MigratorCgrCfg().OutDataDBOpts[utils.RedisSentinelNameCfg] = dfltCfg.DataDbCfg().Opts.RedisSentinel
+		if dfltCfg.MigratorCgrCfg().OutDataDBOpts.RedisSentinel == mgrCfg.MigratorCgrCfg().OutDataDBOpts.RedisSentinel {
+			mgrCfg.MigratorCgrCfg().OutDataDBOpts.RedisSentinel = dfltCfg.DataDbCfg().Opts.RedisSentinel
 		}
 	} else {
-		mgrCfg.MigratorCgrCfg().OutDataDBOpts[utils.RedisSentinelNameCfg] = *outDataDBRedisSentinel
+		mgrCfg.MigratorCgrCfg().OutDataDBOpts.RedisSentinel = *outDataDBRedisSentinel
 	}
 
 	sameDataDB = mgrCfg.MigratorCgrCfg().OutDataDBType == mgrCfg.DataDbCfg().Type &&

cmd/cgr-migrator/cgr-migrator_test.go

@@ -20,6 +20,7 @@ package main
 
 import (
 	"testing"
+	"time"
 )
 
 // if the flag change this should fail
@@ -85,19 +86,19 @@ func TestFlags(t *testing.T) {
 	} else if !*dbRedisCluster {
 		t.Errorf("Expected true received:%v ", *dbRedisCluster)
 	}
-	if err := cgrMigratorFlags.Parse([]string{"-redisClusterSync", "true"}); err != nil {
+	if err := cgrMigratorFlags.Parse([]string{"-redisClusterSync", "3s"}); err != nil {
 		t.Fatal(err)
-	} else if *dbRedisClusterSync != "true" {
+	} else if *dbRedisClusterSync != 3*time.Second {
 		t.Errorf("Expected true received:%v ", *dbRedisClusterSync)
 	}
-	if err := cgrMigratorFlags.Parse([]string{"-redisClusterOndownDelay", "true"}); err != nil {
+	if err := cgrMigratorFlags.Parse([]string{"-redisClusterOndownDelay", "3s"}); err != nil {
 		t.Fatal(err)
-	} else if *dbRedisClusterDownDelay != "true" {
+	} else if *dbRedisClusterDownDelay != 3*time.Second {
 		t.Errorf("Expected true received:%v ", *dbRedisClusterDownDelay)
 	}
-	if err := cgrMigratorFlags.Parse([]string{"-mongoQueryTimeout", "true"}); err != nil {
+	if err := cgrMigratorFlags.Parse([]string{"-mongoQueryTimeout", "3s"}); err != nil {
 		t.Fatal(err)
-	} else if *dbQueryTimeout != "true" {
+	} else if *dbQueryTimeout != 3*time.Second {
 		t.Errorf("Expected true received:%v ", *dbQueryTimeout)
 	}
 	if err := cgrMigratorFlags.Parse([]string{"-redisTLS", "true"}); err != nil {

config/apis_test.go

@@ -295,7 +295,7 @@ func TestGetSectionAsMap(t *testing.T) {
 			"redisSentinel":           "",
 			"redisCluster":            false,
 			"redisClusterSync":        "5s",
-			"redisClusterOndownDelay": "0",
+			"redisClusterOndownDelay": "0s",
 			"mongoQueryTimeout":       "10s",
 			"redisTLS":                false,
 			"redisClientCertificate":  "",

config/config_defaults.go

@@ -142,7 +142,7 @@ const CGRATES_CFG_JSON = `
 	"opts": {
 		"sqlMaxOpenConns": 100,				// maximum database connections opened, not applying for mongo
 		"sqlMaxIdleConns": 10,				// maximum database connections idle, not applying for mongo
-		"sqlConnMaxLifetime": 0, 			// maximum amount of time in seconds a connection may be reused (0 for unlimited), not applying for mongo
+		"sqlConnMaxLifetime": "0", 			// maximum amount of time a connection may be reused (0 for unlimited), not applying for mongo
 		"mongoQueryTimeout":"10s",			// timeout for query when mongo is used
 		"sslMode":"disable",				// sslMode in case of *postgres
 		"mysqlLocation": "Local",			// the location the time from mysql is retrived
@@ -493,7 +493,7 @@ const CGRATES_CFG_JSON = `
 				// SQL
 				// "sqlMaxIdleConns": 0,						// SQLMaxIdleConns    
 				// "sqlMaxOpenConns": 0,						// SQLMaxOpenConns
-				// "sqlConnMaxLifetime": 0,						// SQLMaxConnLifetime 
+				// "sqlConnMaxLifetime": "0",						// SQLConnMaxLifetime 
 
 
 				// "sqlTableName":"cdrs", 						// the name of the table from where the events are exported

config/config_json_test.go

@@ -313,16 +313,16 @@ func TestDfDataDbJsonCfg(t *testing.T) {
 		Replication_filtered: utils.BoolPointer(false),
 		Remote_conn_id:       utils.StringPointer(""),
 		Replication_cache:    utils.StringPointer(""),
-		Opts: map[string]interface{}{
-			utils.RedisSentinelNameCfg:       "",
-			utils.MongoQueryTimeoutCfg:       "10s",
-			utils.RedisClusterCfg:            false,
-			utils.RedisClusterOnDownDelayCfg: "0",
-			utils.RedisClusterSyncCfg:        "5s",
-			utils.RedisTLSCfg:                false,
-			utils.RedisClientCertificateCfg:  "",
-			utils.RedisClientKeyCfg:          "",
-			utils.RedisCACertificateCfg:      "",
+		Opts: &DBOptsJson{
+			RedisCACertificate:      utils.StringPointer(utils.EmptyString),
+			RedisClientCertificate:  utils.StringPointer(utils.EmptyString),
+			RedisClientKey:          utils.StringPointer(utils.EmptyString),
+			RedisCluster:            utils.BoolPointer(false),
+			RedisTLS:                utils.BoolPointer(false),
+			RedisSentinel:           utils.StringPointer(utils.EmptyString),
+			MongoQueryTimeout:       utils.StringPointer("10s"),
+			RedisClusterOndownDelay: utils.StringPointer("0"),
+			RedisClusterSync:        utils.StringPointer("5s"),
 		},
 		Items: map[string]*ItemOptJson{
 			utils.MetaAccounts: {
@@ -421,13 +421,13 @@ func TestDfStorDBJsonCfg(t *testing.T) {
 		Db_password:           utils.StringPointer(""),
 		String_indexed_fields: &[]string{},
 		Prefix_indexed_fields: &[]string{},
-		Opts: map[string]interface{}{
-			utils.MongoQueryTimeoutCfg:  "10s",
-			utils.SQLMaxOpenConnsCfg:    100.,
-			utils.SQLMaxIdleConnsCfg:    10.,
-			utils.SQLConnMaxLifetimeCfg: 0.,
-			utils.SSLModeCfg:            utils.PostgressSSLModeDisable,
-			utils.MysqlLocation:         "Local",
+		Opts: &DBOptsJson{
+			MongoQueryTimeout:  utils.StringPointer("10s"),
+			SQLMaxOpenConns:    utils.IntPointer(100),
+			SQLMaxIdleConns:    utils.IntPointer(10),
+			SQLConnMaxLifetime: utils.StringPointer("0"),
+			SSLMode:            utils.StringPointer(utils.PostgressSSLModeDisable),
+			MySQLLocation:      utils.StringPointer("Local"),
 		},
 		Items: map[string]*ItemOptJson{
 			utils.CacheTBLTPResources: {
@@ -1824,16 +1824,16 @@ func TestDfMigratorCfg(t *testing.T) {
 		Out_storDB_user:     utils.StringPointer("cgrates"),
 		Out_storDB_password: utils.StringPointer(""),
 		Users_filters:       &[]string{},
-		Out_storDB_opts:     make(map[string]interface{}),
-		Out_dataDB_opts: map[string]interface{}{
-			utils.RedisSentinelNameCfg:       "",
-			utils.RedisClusterCfg:            false,
-			utils.RedisClusterSyncCfg:        "5s",
-			utils.RedisClusterOnDownDelayCfg: "0",
-			utils.RedisTLSCfg:                false,
-			utils.RedisClientCertificateCfg:  "",
-			utils.RedisClientKeyCfg:          "",
-			utils.RedisCACertificateCfg:      "",
+		Out_storDB_opts:     &DBOptsJson{},
+		Out_dataDB_opts: &DBOptsJson{
+			RedisClusterSync:        utils.StringPointer("5s"),
+			RedisClusterOndownDelay: utils.StringPointer("0"),
+			RedisCACertificate:      utils.StringPointer(utils.EmptyString),
+			RedisClientCertificate:  utils.StringPointer(utils.EmptyString),
+			RedisClientKey:          utils.StringPointer(utils.EmptyString),
+			RedisCluster:            utils.BoolPointer(false),
+			RedisSentinel:           utils.StringPointer(utils.EmptyString),
+			RedisTLS:                utils.BoolPointer(false),
 		},
 	}
 	dfCgrJSONCfg, err := NewCgrJsonCfgFromBytes([]byte(CGRATES_CFG_JSON))

config/configsanity_test.go

@@ -1549,8 +1549,8 @@ func TestConfigSanityStorDB(t *testing.T) {
 	cfg = NewDefaultCGRConfig()
 	cfg.storDbCfg = &StorDbCfg{
 		Type: utils.Postgres,
-		Opts: map[string]interface{}{
-			utils.SSLModeCfg: "wrongSSLMode",
+		Opts: &StorDBOpts{
+			SSLMode: "wrongSSLMode",
 		},
 	}
 	expected := "<stor_db> unsupported sslmode for storDB"

config/datadbcfg_test.go

@@ -41,8 +41,8 @@ func TestDataDbCfgloadFromJsonCfg(t *testing.T) {
 				Remote:    utils.BoolPointer(true),
 			},
 		},
-		Opts: map[string]interface{}{
-			utils.RedisSentinelNameCfg: "sentinel",
+		Opts: &DBOptsJson{
+			RedisSentinel: utils.StringPointer("sentinel"),
 		},
 	}
 	expected := &DataDbCfg{
@@ -60,8 +60,8 @@ func TestDataDbCfgloadFromJsonCfg(t *testing.T) {
 				Remote:    true,
 			},
 		},
-		Opts: map[string]interface{}{
-			utils.RedisSentinelNameCfg: "sentinel",
+		Opts: &DataDBOpts{
+			RedisSentinel: "sentinel",
 		},
 	}
 	jsnCfg := NewDefaultCGRConfig()
@@ -73,9 +73,9 @@ func TestDataDbCfgloadFromJsonCfg(t *testing.T) {
 		if !reflect.DeepEqual(expected.Items[utils.MetaAccounts], jsnCfg.dataDbCfg.Items[utils.MetaAccounts]) {
 			t.Errorf("Expected %+v \n, received %+v", utils.ToJSON(expected.Items[utils.MetaAccounts]),
 				utils.ToJSON(jsnCfg.dataDbCfg.Items[utils.MetaAccounts]))
-		} else if !reflect.DeepEqual(expected.Opts[utils.RedisSentinelNameCfg], jsnCfg.dataDbCfg.Opts[utils.RedisSentinelNameCfg]) {
-			t.Errorf("Expected %+v \n, received %+v", utils.ToJSON(expected.Opts[utils.RedisSentinelNameCfg]),
-				utils.ToJSON(jsnCfg.dataDbCfg.Opts[utils.RedisSentinelNameCfg]))
+		} else if !reflect.DeepEqual(expected.Opts.RedisSentinel, jsnCfg.dataDbCfg.Opts.RedisSentinel) {
+			t.Errorf("Expected %+v \n, received %+v", utils.ToJSON(expected.Opts.RedisSentinel),
+				utils.ToJSON(jsnCfg.dataDbCfg.Opts.RedisSentinel))
 		} else if !reflect.DeepEqual(expected.RplConns, jsnCfg.dataDbCfg.RplConns) {
 			t.Errorf("Expected %+v \n, received %+v", expected.RplConns, jsnCfg.dataDbCfg.RplConns)
 		}
@@ -125,7 +125,7 @@ func TestItemCfgloadFromJson(t *testing.T) {
 
 func TestDataDbCfgloadFromJsonCfgPort(t *testing.T) {
 	var dbcfg DataDbCfg
-	dbcfg.Opts = make(map[string]interface{})
+	dbcfg.Opts = &DataDBOpts{}
 	cfgJSONStr := `{
 "data_db": {
 	"db_type": "mongo",
@@ -133,7 +133,7 @@ func TestDataDbCfgloadFromJsonCfgPort(t *testing.T) {
 }`
 	expected := DataDbCfg{
 		Type: "mongo",
-		Opts: make(map[string]interface{}),
+		Opts: &DataDBOpts{},
 	}
 	if jsnCfg, err := NewCgrJsonCfgFromBytes([]byte(cfgJSONStr)); err != nil {
 		t.Error(err)
@@ -151,7 +151,7 @@ func TestDataDbCfgloadFromJsonCfgPort(t *testing.T) {
 	expected = DataDbCfg{
 		Type: "mongo",
 		Port: "27017",
-		Opts: make(map[string]interface{}),
+		Opts: &DataDBOpts{},
 	}
 	if jsnCfg, err := NewCgrJsonCfgFromBytes([]byte(cfgJSONStr)); err != nil {
 		t.Error(err)
@@ -169,7 +169,7 @@ func TestDataDbCfgloadFromJsonCfgPort(t *testing.T) {
 	expected = DataDbCfg{
 		Type: "internal",
 		Port: "internal",
-		Opts: make(map[string]interface{}),
+		Opts: &DataDBOpts{},
 	}
 	if jsnCfg, err := NewCgrJsonCfgFromBytes([]byte(cfgJSONStr)); err != nil {
 		t.Error(err)
@@ -197,7 +197,7 @@ func TestDataDBRemoteReplication(t *testing.T) {
 	}
 }`
 
-	dbcfg.Opts = make(map[string]interface{})
+	dbcfg.Opts = &DataDBOpts{}
 	expected = DataDbCfg{
 		Type:     "redis",
 		Host:     "127.0.0.1",
@@ -206,8 +206,8 @@ func TestDataDBRemoteReplication(t *testing.T) {
 		User:     "cgrates",
 		Password: "password",
 		RmtConns: []string{"Conn1"},
-		Opts: map[string]interface{}{
-			utils.RedisSentinelNameCfg: "sentinel",
+		Opts: &DataDBOpts{
+			RedisSentinel: "sentinel",
 		},
 	}
 	if jsnCfg, err := NewCgrJsonCfgFromBytes([]byte(cfgJSONStr)); err != nil {
@@ -233,8 +233,8 @@ func TestDataDBRemoteReplication(t *testing.T) {
 		Name:     "10",
 		User:     "cgrates",
 		Password: "password",
-		Opts: map[string]interface{}{
-			utils.RedisSentinelNameCfg: "sentinel",
+		Opts: &DataDBOpts{
+			RedisSentinel: "sentinel",
 		},
 		RmtConns: []string{"Conn1"},
 		RplConns: []string{"Conn2"},
@@ -262,8 +262,8 @@ func TestDataDBRemoteReplication(t *testing.T) {
 		Name:     "10",
 		User:     "cgrates",
 		Password: "password",
-		Opts: map[string]interface{}{
-			utils.RedisSentinelNameCfg: "sentinel",
+		Opts: &DataDBOpts{
+			RedisSentinel: "sentinel",
 		},
 		RmtConns: []string{"Conn1", "Conn2", "Conn3"},
 		RplConns: []string{"Conn4", "Conn5"},
@@ -310,12 +310,12 @@ func TestDataDbCfgloadFromJsonCfgItems(t *testing.T) {
 				Replicate: true,
 			},
 		},
-		Opts: map[string]interface{}{
-			utils.RedisSentinelNameCfg: "sentinel",
+		Opts: &DataDBOpts{
+			RedisSentinel: "sentinel",
 		},
 	}
 	dbcfg.Items = make(map[string]*ItemOpt)
-	dbcfg.Opts = make(map[string]interface{})
+	dbcfg.Opts = &DataDBOpts{}
 	if jsnCfg, err := NewCgrJsonCfgFromBytes([]byte(cfgJSONStr)); err != nil {
 		t.Error(err)
 	} else if err = dbcfg.Load(context.Background(), jsnCfg, nil); err != nil {
@@ -352,8 +352,8 @@ func TestDataDbCfgloadFromJsonCfgItems(t *testing.T) {
 		Name:     "10",
 		User:     "cgrates",
 		Password: "password",
-		Opts: map[string]interface{}{
-			utils.RedisSentinelNameCfg: "sentinel",
+		Opts: &DataDBOpts{
+			RedisSentinel: "sentinel",
 		},
 		RmtConns: []string{"Conn1"},
 		Items: map[string]*ItemOpt{
@@ -407,8 +407,8 @@ func TestDataDbCfgloadFromJsonCfgItems(t *testing.T) {
 		Name:     "10",
 		User:     "cgrates",
 		Password: "password",
-		Opts: map[string]interface{}{
-			utils.RedisSentinelNameCfg: "sentinel",
+		Opts: &DataDBOpts{
+			RedisSentinel: "sentinel",
 		},
 		RmtConns: []string{"Conn1"},
 		Items: map[string]*ItemOpt{
@@ -493,8 +493,8 @@ func TestCloneDataDB(t *testing.T) {
 				Remote:    utils.BoolPointer(true),
 			},
 		},
-		Opts: map[string]interface{}{
-			utils.RedisSentinelNameCfg: "sentinel",
+		Opts: &DBOptsJson{
+			RedisSentinel: utils.StringPointer("sentinel"),
 		},
 	}
 	jsnCfg := NewDefaultCGRConfig()
@@ -505,9 +505,9 @@ func TestCloneDataDB(t *testing.T) {
 		if !reflect.DeepEqual(rcv.Items[utils.MetaAccounts], jsnCfg.dataDbCfg.Items[utils.MetaAccounts]) {
 			t.Errorf("Expected %+v \n, received %+v", utils.ToJSON(rcv.Items[utils.MetaAccounts]),
 				utils.ToJSON(jsnCfg.dataDbCfg.Items[utils.MetaAccounts]))
-		} else if !reflect.DeepEqual(rcv.Opts[utils.RedisSentinelNameCfg], jsnCfg.dataDbCfg.Opts[utils.RedisSentinelNameCfg]) {
-			t.Errorf("Expected %+v \n, received %+v", utils.ToJSON(rcv.Opts[utils.RedisSentinelNameCfg]),
-				utils.ToJSON(jsnCfg.dataDbCfg.Opts[utils.RedisSentinelNameCfg]))
+		} else if !reflect.DeepEqual(rcv.Opts.RedisSentinel, jsnCfg.dataDbCfg.Opts.RedisSentinel) {
+			t.Errorf("Expected %+v \n, received %+v", utils.ToJSON(rcv.Opts.RedisSentinel),
+				utils.ToJSON(jsnCfg.dataDbCfg.Opts.RedisSentinel))
 		} else if !reflect.DeepEqual(rcv.RplConns, jsnCfg.dataDbCfg.RplConns) {
 			t.Errorf("Expected %+v \n, received %+v", rcv.RplConns, jsnCfg.dataDbCfg.RplConns)
 		}
@@ -650,7 +650,9 @@ func TestDiffDataDbJsonCfg(t *testing.T) {
 		RplFiltered: true,
 		RplCache:    "RplCache",
 		Items:       map[string]*ItemOpt{},
-		Opts:        map[string]interface{}{},
+		Opts: &DataDBOpts{
+			RedisSentinel: "sentinel1",
+		},
 	}
 
 	v2 := &DataDbCfg{
@@ -673,8 +675,8 @@ func TestDiffDataDbJsonCfg(t *testing.T) {
 				APIKey:    "APIKey2",
 			},
 		},
-		Opts: map[string]interface{}{
-			"OPT_1": "OptValue",
+		Opts: &DataDBOpts{
+			RedisSentinel: "sentinel2",
 		},
 	}
 
@@ -698,8 +700,8 @@ func TestDiffDataDbJsonCfg(t *testing.T) {
 				Api_key:   utils.StringPointer("APIKey2"),
 			},
 		},
-		Opts: map[string]interface{}{
-			"OPT_1": "OptValue",
+		Opts: &DBOptsJson{
+			RedisSentinel: utils.StringPointer("sentinel2"),
 		},
 	}
 
@@ -711,7 +713,7 @@ func TestDiffDataDbJsonCfg(t *testing.T) {
 	v2_2 := v1
 	expected2 := &DbJsonCfg{
 		Items: map[string]*ItemOptJson{},
-		Opts:  map[string]interface{}{},
+		Opts:  &DBOptsJson{},
 	}
 	rcv = diffDataDbJsonCfg(d, v1, v2_2)
 	if !reflect.DeepEqual(rcv, expected2) {

config/migratorcfg_test.go

@@ -20,6 +20,7 @@ package config
 import (
 	"reflect"
 	"testing"
+	"time"
 
 	"github.com/cgrates/cgrates/utils"
 )
@@ -39,12 +40,12 @@ func TestMigratorCgrCfgloadFromJsonCfg(t *testing.T) {
 		Out_storDB_name:     utils.StringPointer(utils.CGRateSLwr),
 		Out_storDB_user:     utils.StringPointer(utils.CGRateSLwr),
 		Out_storDB_password: utils.StringPointer(utils.EmptyString),
-		Out_dataDB_opts: map[string]interface{}{
-			utils.RedisClusterCfg:     true,
-			utils.RedisClusterSyncCfg: "10s",
+		Out_dataDB_opts: &DBOptsJson{
+			RedisCluster:     utils.BoolPointer(true),
+			RedisClusterSync: utils.StringPointer("10s"),
 		},
-		Out_storDB_opts: map[string]interface{}{
-			utils.RedisSentinelNameCfg: utils.EmptyString,
+		Out_storDB_opts: &DBOptsJson{
+			RedisSentinel: utils.StringPointer(utils.EmptyString),
 		},
 	}
 	expected := &MigratorCgrCfg{
@@ -61,19 +62,11 @@ func TestMigratorCgrCfgloadFromJsonCfg(t *testing.T) {
 		OutStorDBName:     utils.CGRateSLwr,
 		OutStorDBUser:     utils.CGRateSLwr,
 		OutStorDBPassword: utils.EmptyString,
-		OutDataDBOpts: map[string]interface{}{
-			utils.RedisSentinelNameCfg:       utils.EmptyString,
-			utils.RedisClusterCfg:            true,
-			utils.RedisClusterSyncCfg:        "10s",
-			utils.RedisClusterOnDownDelayCfg: "0",
-			utils.RedisTLSCfg:                false,
-			utils.RedisClientCertificateCfg:  "",
-			utils.RedisClientKeyCfg:          "",
-			utils.RedisCACertificateCfg:      "",
-		},
-		OutStorDBOpts: map[string]interface{}{
-			utils.RedisSentinelNameCfg: utils.EmptyString,
+		OutDataDBOpts: &DataDBOpts{
+			RedisCluster:     true,
+			RedisClusterSync: 10 * time.Second,
 		},
+		OutStorDBOpts: &StorDBOpts{},
 	}
 	cfg := NewDefaultCGRConfig()
 	if err = cfg.migratorCgrCfg.loadFromJSONCfg(cfgJSON); err != nil {
@@ -118,17 +111,23 @@ func TestMigratorCgrCfgAsMapInterface(t *testing.T) {
 		utils.OutStorDBPasswordCfg: "",
 		utils.UsersFiltersCfg:      []string{"users", "filters", "Account"},
 		utils.OutStorDBOptsCfg: map[string]interface{}{
-			utils.RedisClusterCfg: true,
+			utils.MongoQueryTimeoutCfg:  "0s",
+			utils.MysqlLocation:         utils.EmptyString,
+			utils.SQLConnMaxLifetimeCfg: "0s",
+			utils.SQLMaxIdleConnsCfg:    0,
+			utils.SQLMaxOpenConnsCfg:    0,
+			utils.SSLModeCfg:            utils.EmptyString,
 		},
 		utils.OutDataDBOptsCfg: map[string]interface{}{
 			utils.RedisSentinelNameCfg:       "",
 			utils.RedisClusterCfg:            true,
 			utils.RedisClusterSyncCfg:        "2s",
-			utils.RedisClusterOnDownDelayCfg: "1",
+			utils.RedisClusterOnDownDelayCfg: "1ns",
 			utils.RedisTLSCfg:                false,
 			utils.RedisClientCertificateCfg:  "",
 			utils.RedisClientKeyCfg:          "",
 			utils.RedisCACertificateCfg:      "",
+			utils.MongoQueryTimeoutCfg:       "0s",
 		},
 	}
 	if cgrCfg, err := NewCGRConfigFromJSONStringWithDefaults(cfgJSONStr); err != nil {
@@ -162,12 +161,20 @@ func TestMigratorCgrCfgAsMapInterface1(t *testing.T) {
 		utils.OutStorDBUserCfg:     "cgrates",
 		utils.OutStorDBPasswordCfg: "out_stordb_password",
 		utils.UsersFiltersCfg:      []string{"users", "filters", "Account"},
-		utils.OutStorDBOptsCfg:     map[string]interface{}{},
+		utils.OutStorDBOptsCfg: map[string]interface{}{
+			utils.MongoQueryTimeoutCfg:  "0s",
+			utils.MysqlLocation:         utils.EmptyString,
+			utils.SQLConnMaxLifetimeCfg: "0s",
+			utils.SQLMaxIdleConnsCfg:    0,
+			utils.SQLMaxOpenConnsCfg:    0,
+			utils.SSLModeCfg:            utils.EmptyString,
+		},
 		utils.OutDataDBOptsCfg: map[string]interface{}{
+			utils.MongoQueryTimeoutCfg:       "0s",
 			utils.RedisSentinelNameCfg:       "out_datadb_redis_sentinel",
 			utils.RedisClusterCfg:            false,
 			utils.RedisClusterSyncCfg:        "5s",
-			utils.RedisClusterOnDownDelayCfg: "0",
+			utils.RedisClusterOnDownDelayCfg: "0s",
 			utils.RedisTLSCfg:                false,
 			utils.RedisClientCertificateCfg:  "",
 			utils.RedisClientKeyCfg:          "",
@@ -200,16 +207,24 @@ func TestMigratorCgrCfgAsMapInterface2(t *testing.T) {
 		utils.OutStorDBUserCfg:     "cgrates",
 		utils.OutStorDBPasswordCfg: "",
 		utils.UsersFiltersCfg:      []string(nil),
-		utils.OutStorDBOptsCfg:     map[string]interface{}{},
+		utils.OutStorDBOptsCfg: map[string]interface{}{
+			utils.MongoQueryTimeoutCfg:  "0s",
+			utils.MysqlLocation:         utils.EmptyString,
+			utils.SQLConnMaxLifetimeCfg: "0s",
+			utils.SQLMaxIdleConnsCfg:    0,
+			utils.SQLMaxOpenConnsCfg:    0,
+			utils.SSLModeCfg:            utils.EmptyString,
+		},
 		utils.OutDataDBOptsCfg: map[string]interface{}{
 			utils.RedisSentinelNameCfg:       "",
 			utils.RedisClusterCfg:            false,
 			utils.RedisClusterSyncCfg:        "5s",
-			utils.RedisClusterOnDownDelayCfg: "0",
+			utils.RedisClusterOnDownDelayCfg: "0s",
 			utils.RedisTLSCfg:                false,
 			utils.RedisClientCertificateCfg:  "",
 			utils.RedisClientKeyCfg:          "",
 			utils.RedisCACertificateCfg:      "",
+			utils.MongoQueryTimeoutCfg:       "0s",
 		},
 	}
 	if cgrCfg, err := NewCGRConfigFromJSONStringWithDefaults(cfgJSONStr); err != nil {
@@ -236,19 +251,11 @@ func TestMigratorCgrCfgClone(t *testing.T) {
 		OutStorDBUser:     utils.CGRateSLwr,
 		OutStorDBPassword: utils.EmptyString,
 		UsersFilters:      []string{utils.AccountField},
-		OutDataDBOpts: map[string]interface{}{
-			utils.RedisSentinelNameCfg:       utils.EmptyString,
-			utils.RedisClusterCfg:            true,
-			utils.RedisClusterSyncCfg:        "10s",
-			utils.RedisClusterOnDownDelayCfg: "0",
-			utils.RedisTLSCfg:                false,
-			utils.RedisClientCertificateCfg:  "",
-			utils.RedisClientKeyCfg:          "",
-			utils.RedisCACertificateCfg:      "",
-		},
-		OutStorDBOpts: map[string]interface{}{
-			utils.RedisSentinelNameCfg: utils.EmptyString,
+		OutDataDBOpts: &DataDBOpts{
+			RedisCluster:     true,
+			RedisClusterSync: 10 * time.Second,
 		},
+		OutStorDBOpts: &StorDBOpts{},
 	}
 	rcv := sa.Clone()
 	if !reflect.DeepEqual(sa, rcv) {
@@ -257,10 +264,7 @@ func TestMigratorCgrCfgClone(t *testing.T) {
 	if rcv.UsersFilters[0] = ""; sa.UsersFilters[0] != utils.AccountField {
 		t.Errorf("Expected clone to not modify the cloned")
 	}
-	if rcv.OutDataDBOpts[utils.RedisSentinelNameCfg] = "1"; sa.OutDataDBOpts[utils.RedisSentinelNameCfg] != "" {
-		t.Errorf("Expected clone to not modify the cloned")
-	}
-	if rcv.OutStorDBOpts[utils.RedisSentinelNameCfg] = "1"; sa.OutStorDBOpts[utils.RedisSentinelNameCfg] != "" {
+	if rcv.OutDataDBOpts.RedisSentinel = "1"; sa.OutDataDBOpts.RedisSentinel != "" {
 		t.Errorf("Expected clone to not modify the cloned")
 	}
 }
@@ -282,8 +286,8 @@ func TestDiffMigratorCfgJson(t *testing.T) {
 		OutStorDBName:     "cgrates_redis",
 		OutStorDBUser:     "cgrates_redis_user",
 		OutStorDBPassword: "CGRateS.org_redis",
-		OutDataDBOpts:     map[string]interface{}{},
-		OutStorDBOpts:     map[string]interface{}{},
+		OutDataDBOpts:     &DataDBOpts{},
+		OutStorDBOpts:     &StorDBOpts{},
 		UsersFilters:      []string{},
 	}
 
@@ -301,14 +305,11 @@ func TestDiffMigratorCfgJson(t *testing.T) {
 		OutDataDBName:     "cgrates_redis",
 		OutDataDBUser:     "cgrates_redis_user",
 		OutDataDBPassword: "CGRateS.org_redis",
-		OutDataDBOpts: map[string]interface{}{
-			utils.RedisSentinelNameCfg: utils.EmptyString,
-			utils.RedisClusterCfg:      true,
+		OutDataDBOpts: &DataDBOpts{
+			RedisCluster: true,
 		},
-		OutStorDBOpts: map[string]interface{}{
-			utils.RedisSentinelNameCfg: utils.EmptyString,
-		},
-		UsersFilters: []string{"cgrates_redis_user"},
+		OutStorDBOpts: &StorDBOpts{},
+		UsersFilters:  []string{"cgrates_redis_user"},
 	}
 
 	expected := &MigratorCfgJson{
@@ -325,14 +326,11 @@ func TestDiffMigratorCfgJson(t *testing.T) {
 		Out_dataDB_name:     utils.StringPointer("cgrates_redis"),
 		Out_dataDB_user:     utils.StringPointer("cgrates_redis_user"),
 		Out_dataDB_password: utils.StringPointer("CGRateS.org_redis"),
-		Out_dataDB_opts: map[string]interface{}{
-			utils.RedisSentinelNameCfg: utils.EmptyString,
-			utils.RedisClusterCfg:      true,
+		Out_dataDB_opts: &DBOptsJson{
+			RedisCluster: utils.BoolPointer(true),
 		},
-		Out_storDB_opts: map[string]interface{}{
-			utils.RedisSentinelNameCfg: utils.EmptyString,
-		},
-		Users_filters: &[]string{"cgrates_redis_user"},
+		Out_storDB_opts: &DBOptsJson{},
+		Users_filters:   &[]string{"cgrates_redis_user"},
 	}
 
 	rcv := diffMigratorCfgJson(d, v1, v2)
@@ -342,8 +340,8 @@ func TestDiffMigratorCfgJson(t *testing.T) {
 
 	v1 = v2
 	expected = &MigratorCfgJson{
-		Out_dataDB_opts: map[string]interface{}{},
-		Out_storDB_opts: map[string]interface{}{},
+		Out_dataDB_opts: &DBOptsJson{},
+		Out_storDB_opts: &DBOptsJson{},
 	}
 	rcv = diffMigratorCfgJson(d, v1, v2)
 	if !reflect.DeepEqual(rcv, expected) {

config/stordbcfg_test.go

@@ -20,6 +20,7 @@ package config
 import (
 	"reflect"
 	"testing"
+	"time"
 
 	"github.com/cgrates/birpc/context"
 	"github.com/cgrates/cgrates/utils"
@@ -43,11 +44,11 @@ func TestStoreDbCfgloadFromJsonCfgCase1(t *testing.T) {
 				Replicate: utils.BoolPointer(false),
 			},
 		},
-		Opts: map[string]interface{}{
-			utils.SQLMaxOpenConnsCfg:    100.,
-			utils.SQLMaxIdleConnsCfg:    10.,
-			utils.SQLConnMaxLifetimeCfg: 0.,
-			utils.MysqlLocation:         "UTC",
+		Opts: &DBOptsJson{
+			SQLMaxOpenConns:    utils.IntPointer(100),
+			SQLMaxIdleConns:    utils.IntPointer(10),
+			SQLConnMaxLifetime: utils.StringPointer("0"),
+			MySQLLocation:      utils.StringPointer("UTC"),
 		},
 	}
 	expected := &StorDbCfg{
@@ -67,13 +68,12 @@ func TestStoreDbCfgloadFromJsonCfgCase1(t *testing.T) {
 				Replicate: false,
 			},
 		},
-		Opts: map[string]interface{}{
-			utils.SQLMaxOpenConnsCfg:    100.,
-			utils.SQLMaxIdleConnsCfg:    10.,
-			utils.SQLConnMaxLifetimeCfg: 0.,
-			utils.MongoQueryTimeoutCfg:  "10s",
-			utils.SSLModeCfg:            "disable",
-			utils.MysqlLocation:         "UTC",
+		Opts: &StorDBOpts{
+			SQLMaxOpenConns:   100,
+			SQLMaxIdleConns:   10,
+			MongoQueryTimeout: 10 * time.Second,
+			SSLMode:           "disable",
+			MySQLLocation:     "UTC",
 		},
 	}
 	jsonCfg := NewDefaultCGRConfig()
@@ -125,10 +125,10 @@ func TestStoreDbCfgloadFromJsonCfgPort(t *testing.T) {
 	"db_type": "mongo",
 	}
 }`
-	dbcfg.Opts = make(map[string]interface{})
+	dbcfg.Opts = &StorDBOpts{}
 	expected := StorDbCfg{
 		Type: "mongo",
-		Opts: make(map[string]interface{}),
+		Opts: &StorDBOpts{},
 	}
 	if jsnCfg, err := NewCgrJsonCfgFromBytes([]byte(cfgJSONStr)); err != nil {
 		t.Error(err)
@@ -146,7 +146,7 @@ func TestStoreDbCfgloadFromJsonCfgPort(t *testing.T) {
 	expected = StorDbCfg{
 		Type: "mongo",
 		Port: "27017",
-		Opts: make(map[string]interface{}),
+		Opts: &StorDBOpts{},
 	}
 	if jsnCfg, err := NewCgrJsonCfgFromBytes([]byte(cfgJSONStr)); err != nil {
 		t.Error(err)
@@ -164,7 +164,7 @@ func TestStoreDbCfgloadFromJsonCfgPort(t *testing.T) {
 	expected = StorDbCfg{
 		Type: "internal",
 		Port: "internal",
-		Opts: make(map[string]interface{}),
+		Opts: &StorDBOpts{},
 	}
 	if jsnCfg, err := NewCgrJsonCfgFromBytes([]byte(cfgJSONStr)); err != nil {
 		t.Error(err)
@@ -191,7 +191,7 @@ func TestStorDbCfgAsMapInterface(t *testing.T) {
 			"opts": {	
 				"sqlMaxOpenConns": 100,					
 				"sqlMaxIdleConns": 10,					
-				"sqlConnMaxLifetime": 0, 			
+				"sqlConnMaxLifetime": "0", 			
 				"mongoQueryTimeout":"10s",
 				"sslMode":"disable",		
 				"mysqlLocation": "UTC",			
@@ -215,9 +215,9 @@ func TestStorDbCfgAsMapInterface(t *testing.T) {
 		utils.RemoteConnsCfg:         []string{"*conn1"},
 		utils.ReplicationConnsCfg:    []string{"*conn1"},
 		utils.OptsCfg: map[string]interface{}{
-			utils.SQLMaxOpenConnsCfg:    100.,
-			utils.SQLMaxIdleConnsCfg:    10.,
-			utils.SQLConnMaxLifetimeCfg: 0.,
+			utils.SQLMaxOpenConnsCfg:    100,
+			utils.SQLMaxIdleConnsCfg:    10,
+			utils.SQLConnMaxLifetimeCfg: "0s",
 			utils.MongoQueryTimeoutCfg:  "10s",
 			utils.SSLModeCfg:            "disable",
 			utils.MysqlLocation:         "UTC",
@@ -265,12 +265,11 @@ func TestStorDbCfgClone(t *testing.T) {
 				Replicate: false,
 			},
 		},
-		Opts: map[string]interface{}{
-			utils.SQLMaxOpenConnsCfg:    100.,
-			utils.SQLMaxIdleConnsCfg:    10.,
-			utils.SQLConnMaxLifetimeCfg: 0.,
-			utils.MongoQueryTimeoutCfg:  "10s",
-			utils.SSLModeCfg:            "disable",
+		Opts: &StorDBOpts{
+			SQLMaxOpenConns:   100,
+			SQLMaxIdleConns:   10,
+			MongoQueryTimeout: 10 * time.Second,
+			SSLMode:           "disable",
 		},
 	}
 	rcv := ban.Clone()
@@ -294,7 +293,7 @@ func TestStorDbCfgClone(t *testing.T) {
 	if rcv.Items[utils.MetaCDRs].Remote = false; !ban.Items[utils.MetaCDRs].Remote {
 		t.Errorf("Expected clone to not modify the cloned")
 	}
-	if rcv.Opts[utils.SSLModeCfg] = ""; ban.Opts[utils.SSLModeCfg] != "disable" {
+	if rcv.Opts.SSLMode = ""; ban.Opts.SSLMode != "disable" {
 		t.Errorf("Expected clone to not modify the cloned")
 	}
 
@@ -319,7 +318,9 @@ func TestDiffStorDBJsonCfg(t *testing.T) {
 				Remote: false,
 			},
 		},
-		Opts: map[string]interface{}{},
+		Opts: &StorDBOpts{
+			SQLMaxOpenConns: 50,
+		},
 	}
 
 	v2 := &StorDbCfg{
@@ -338,8 +339,8 @@ func TestDiffStorDBJsonCfg(t *testing.T) {
 				Remote: true,
 			},
 		},
-		Opts: map[string]interface{}{
-			"OPT_1": "opt1",
+		Opts: &StorDBOpts{
+			SQLMaxOpenConns: 100,
 		},
 	}
 
@@ -359,8 +360,8 @@ func TestDiffStorDBJsonCfg(t *testing.T) {
 				Remote: utils.BoolPointer(true),
 			},
 		},
-		Opts: map[string]interface{}{
-			"OPT_1": "opt1",
+		Opts: &DBOptsJson{
+			SQLMaxOpenConns: utils.IntPointer(100),
 		},
 	}
 
@@ -372,7 +373,7 @@ func TestDiffStorDBJsonCfg(t *testing.T) {
 	v1 = v2
 	expected = &DbJsonCfg{
 		Items: map[string]*ItemOptJson{},
-		Opts:  map[string]interface{}{},
+		Opts:  &DBOptsJson{},
 	}
 	rcv = diffStorDBDbJsonCfg(d, v1, v2)
 	if !reflect.DeepEqual(rcv, expected) {

data/conf/cgrates/cgrates.json

@@ -449,7 +449,7 @@
 // 				// SQL
 // 				// "sqlMaxIdleConns": 0,						// SQLMaxIdleConns    
 // 				// "sqlMaxOpenConns": 0,						// SQLMaxOpenConns
-// 				// "sqlConnMaxLifetime": 0,						// SQLMaxConnLifetime 
+// 				// "sqlConnMaxLifetime": 0,						// SQLConnMaxLifetime 
 
 
 // 				// "sqlTableName":"cdrs", 						// the name of the table from where the events are exported

services/datadb_test.go

@@ -21,6 +21,7 @@ import (
 	"reflect"
 	"sync"
 	"testing"
+	"time"
 
 	"github.com/cgrates/cgrates/config"
 	"github.com/cgrates/cgrates/engine"
@@ -52,16 +53,9 @@ func TestDataDBCoverage(t *testing.T) {
 		Port: "27017",
 		Name: "10",
 		User: "cgrates",
-		Opts: map[string]interface{}{
-			utils.MongoQueryTimeoutCfg:       "10s",
-			utils.RedisClusterOnDownDelayCfg: "0",
-			utils.RedisClusterSyncCfg:        "5s",
-			utils.RedisClusterCfg:            false,
-			utils.RedisSentinelNameCfg:       "",
-			utils.RedisTLSCfg:                false,
-			utils.RedisClientCertificateCfg:  "",
-			utils.RedisClientKeyCfg:          "",
-			utils.RedisCACertificateCfg:      "",
+		Opts: &config.DataDBOpts{
+			MongoQueryTimeout: 10 * time.Second,
+			RedisClusterSync:  5 * time.Second,
 		},
 		RmtConns: []string{},
 		RplConns: []string{},

services/stordb.go

@@ -21,7 +21,6 @@ package services
 import (
 	"fmt"
 	"sync"
-	"time"
 
 	"github.com/cgrates/birpc/context"
 	"github.com/cgrates/cgrates/config"
@@ -101,11 +100,7 @@ func (db *StorDBService) Reload(*context.Context, context.CancelFunc) (err error
 			return fmt.Errorf("can't conver StorDB of type %s to MongoStorage",
 				db.cfg.StorDbCfg().Type)
 		}
-		var ttl time.Duration
-		if ttl, err = utils.IfaceAsDuration(db.cfg.StorDbCfg().Opts[utils.MongoQueryTimeoutCfg]); err != nil {
-			return
-		}
-		mgo.SetTTL(ttl)
+		mgo.SetTTL(db.cfg.StorDbCfg().Opts.MongoQueryTimeout)
 	} else if db.cfg.StorDbCfg().Type == utils.Postgres ||
 		db.cfg.StorDbCfg().Type == utils.MySQL {
 		msql, canCast := db.db.(*engine.SQLStorage)
@@ -113,19 +108,9 @@ func (db *StorDBService) Reload(*context.Context, context.CancelFunc) (err error
 			return fmt.Errorf("can't conver StorDB of type %s to SQLStorage",
 				db.cfg.StorDbCfg().Type)
 		}
-		var maxConn, maxIdleConn, connMaxLifetime int64
-		if maxConn, err = utils.IfaceAsTInt64(db.cfg.StorDbCfg().Opts[utils.SQLMaxOpenConnsCfg]); err != nil {
-			return
-		}
-		if maxIdleConn, err = utils.IfaceAsTInt64(db.cfg.StorDbCfg().Opts[utils.SQLMaxIdleConnsCfg]); err != nil {
-			return
-		}
-		if connMaxLifetime, err = utils.IfaceAsTInt64(db.cfg.StorDbCfg().Opts[utils.SQLConnMaxLifetimeCfg]); err != nil {
-			return
-		}
-		msql.DB.SetMaxOpenConns(int(maxConn))
-		msql.DB.SetMaxIdleConns(int(maxIdleConn))
-		msql.DB.SetConnMaxLifetime(time.Duration(connMaxLifetime) * time.Second)
+		msql.DB.SetMaxOpenConns(db.cfg.StorDbCfg().Opts.SQLMaxOpenConns)
+		msql.DB.SetMaxIdleConns(db.cfg.StorDbCfg().Opts.SQLMaxIdleConns)
+		msql.DB.SetConnMaxLifetime(db.cfg.StorDbCfg().Opts.SQLConnMaxLifetime)
 	} else if db.cfg.StorDbCfg().Type == utils.Internal {
 		idb, canCast := db.db.(*engine.InternalDB)
 		if !canCast {
@@ -203,5 +188,5 @@ func (db *StorDBService) needsConnectionReload() bool {
 		return true
 	}
 	return db.cfg.StorDbCfg().Type == utils.Postgres &&
-		utils.IfaceAsString(db.oldDBCfg.Opts[utils.SSLModeCfg]) != utils.IfaceAsString(db.cfg.StorDbCfg().Opts[utils.SSLModeCfg])
+		db.oldDBCfg.Opts.SSLMode != db.cfg.StorDbCfg().Opts.SSLMode
 }