Fix compilation errors (incomplete)

2026-02-11 18:16:24 +05:00 · 2021-10-08 13:43:15 +03:00
parent 1c4866ae8a
commit e340c43ccd
8 changed files with 74 additions and 134 deletions
--- a/cmd/cgr-loader/cgr-loader.go
+++ b/cmd/cgr-loader/cgr-loader.go
@@ -56,15 +56,15 @@ var (
 		"The DataDb user's password.")
 	dbDataEncoding = cgrLoaderFlags.String(utils.DBDataEncodingCfg, dfltCfg.GeneralCfg().DBDataEncoding,
 		"The encoding used to store object data in strings")
-	dbRedisSentinel = cgrLoaderFlags.String(utils.RedisSentinelNameCfg, utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisSentinelNameCfg]),
+	dbRedisSentinel = cgrLoaderFlags.String(utils.RedisSentinelNameCfg, dfltCfg.DataDbCfg().Opts.RedisSentinel,
 		"The name of redis sentinel")
 	dbRedisCluster = cgrLoaderFlags.Bool(utils.RedisClusterCfg, false,
 		"Is the redis datadb a cluster")
-	dbRedisClusterSync = cgrLoaderFlags.String(utils.RedisClusterSyncCfg, utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisClusterSyncCfg]),
+	dbRedisClusterSync = cgrLoaderFlags.Duration(utils.RedisClusterSyncCfg, dfltCfg.DataDbCfg().Opts.RedisClusterSync,
 		"The sync interval for the redis cluster")
-	dbRedisClusterDownDelay = cgrLoaderFlags.String(utils.RedisClusterOnDownDelayCfg, utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisClusterOnDownDelayCfg]),
+	dbRedisClusterDownDelay = cgrLoaderFlags.Duration(utils.RedisClusterOnDownDelayCfg, dfltCfg.DataDbCfg().Opts.RedisClusterOndownDelay,
 		"The delay before executing the commands if the redis cluster is in the CLUSTERDOWN state")
-	dbQueryTimeout = cgrLoaderFlags.String(utils.MongoQueryTimeoutCfg, utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.MongoQueryTimeoutCfg]),
+	dbQueryTimeout = cgrLoaderFlags.Duration(utils.MongoQueryTimeoutCfg, dfltCfg.DataDbCfg().Opts.MongoQueryTimeout,
 		"The timeout for queries")
 	dbRedisTls               = cgrLoaderFlags.Bool(utils.RedisTLSCfg, false, "Enable TLS when connecting to Redis")
 	dbRedisClientCertificate = cgrLoaderFlags.String(utils.RedisClientCertificateCfg, utils.EmptyString, "Path to the client certificate")
@@ -165,36 +165,34 @@ func loadConfig() (ldrCfg *config.CGRConfig) {
 		ldrCfg.DataDbCfg().Password = *dataDBPasswd
 	}

-	if *dbRedisSentinel != utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisSentinelNameCfg]) {
-		ldrCfg.DataDbCfg().Opts[utils.RedisSentinelNameCfg] = *dbRedisSentinel
+	if *dbRedisSentinel != dfltCfg.DataDbCfg().Opts.RedisSentinel {
+		ldrCfg.DataDbCfg().Opts.RedisSentinel = *dbRedisSentinel
 	}

-	rdsCls, _ := utils.IfaceAsBool(dfltCfg.DataDbCfg().Opts[utils.RedisClusterCfg])
-	if *dbRedisCluster != rdsCls {
-		ldrCfg.DataDbCfg().Opts[utils.RedisClusterCfg] = *dbRedisCluster
+	if *dbRedisCluster != dfltCfg.DataDbCfg().Opts.RedisCluster {
+		ldrCfg.DataDbCfg().Opts.RedisCluster = *dbRedisCluster
 	}
-	if *dbRedisClusterSync != utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisClusterSyncCfg]) {
-		ldrCfg.DataDbCfg().Opts[utils.RedisClusterSyncCfg] = *dbRedisClusterSync
+	if *dbRedisClusterSync != dfltCfg.DataDbCfg().Opts.RedisClusterSync {
+		ldrCfg.DataDbCfg().Opts.RedisClusterSync = *dbRedisClusterSync
 	}
-	if *dbRedisClusterDownDelay != utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisClusterOnDownDelayCfg]) {
-		ldrCfg.DataDbCfg().Opts[utils.RedisClusterOnDownDelayCfg] = *dbRedisClusterDownDelay
+	if *dbRedisClusterDownDelay != dfltCfg.DataDbCfg().Opts.RedisClusterOndownDelay {
+		ldrCfg.DataDbCfg().Opts.RedisClusterOndownDelay = *dbRedisClusterDownDelay
 	}
-	if *dbQueryTimeout != utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.MongoQueryTimeoutCfg]) {
-		ldrCfg.DataDbCfg().Opts[utils.MongoQueryTimeoutCfg] = *dbQueryTimeout
+	if *dbQueryTimeout != dfltCfg.DataDbCfg().Opts.MongoQueryTimeout {
+		ldrCfg.DataDbCfg().Opts.MongoQueryTimeout = *dbQueryTimeout
 	}

-	rdsTLS, _ := utils.IfaceAsBool(dfltCfg.DataDbCfg().Opts[utils.RedisTLS])
-	if *dbRedisTls != rdsTLS {
-		ldrCfg.DataDbCfg().Opts[utils.RedisTLS] = *dbRedisTls
+	if *dbRedisTls != dfltCfg.DataDbCfg().Opts.RedisTLS {
+		ldrCfg.DataDbCfg().Opts.RedisTLS = *dbRedisTls
 	}
-	if *dbRedisClientCertificate != utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisClientCertificate]) {
-		ldrCfg.DataDbCfg().Opts[utils.RedisClientCertificate] = *dbRedisClientCertificate
+	if *dbRedisClientCertificate != dfltCfg.DataDbCfg().Opts.RedisClientCertificate {
+		ldrCfg.DataDbCfg().Opts.RedisClientCertificate = *dbRedisClientCertificate
 	}
-	if *dbRedisClientKey != utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisClientKey]) {
-		ldrCfg.DataDbCfg().Opts[utils.RedisClientKey] = *dbRedisClientKey
+	if *dbRedisClientKey != dfltCfg.DataDbCfg().Opts.RedisClientKey {
+		ldrCfg.DataDbCfg().Opts.RedisClientKey = *dbRedisClientKey
 	}
-	if *dbRedisCACertificate != utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisCACertificate]) {
-		ldrCfg.DataDbCfg().Opts[utils.RedisCACertificate] = *dbRedisCACertificate
+	if *dbRedisCACertificate != dfltCfg.DataDbCfg().Opts.RedisCACertificate {
+		ldrCfg.DataDbCfg().Opts.RedisCACertificate = *dbRedisCACertificate
 	}

 	if *dbDataEncoding != dfltCfg.GeneralCfg().DBDataEncoding {
--- a/cmd/cgr-migrator/cgr-migrator.go
+++ b/cmd/cgr-migrator/cgr-migrator.go
@@ -65,15 +65,15 @@ var (
 		"the DataDB password")
 	inDBDataEncoding = cgrMigratorFlags.String(utils.DBDataEncodingCfg, dfltCfg.GeneralCfg().DBDataEncoding,
 		"the encoding used to store object Data in strings")
-	inDataDBRedisSentinel = cgrMigratorFlags.String(utils.RedisSentinelNameCfg, utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisSentinelNameCfg]),
+	inDataDBRedisSentinel = cgrMigratorFlags.String(utils.RedisSentinelNameCfg, dfltCfg.DataDbCfg().Opts.RedisSentinel,
 		"the name of redis sentinel")
 	dbRedisCluster = cgrMigratorFlags.Bool(utils.RedisClusterCfg, false,
 		"Is the redis datadb a cluster")
-	dbRedisClusterSync = cgrMigratorFlags.String(utils.RedisClusterSyncCfg, utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisClusterSyncCfg]),
+	dbRedisClusterSync = cgrMigratorFlags.Duration(utils.RedisClusterSyncCfg, dfltCfg.DataDbCfg().Opts.RedisClusterSync,
 		"The sync interval for the redis cluster")
-	dbRedisClusterDownDelay = cgrMigratorFlags.String(utils.RedisClusterOnDownDelayCfg, utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisClusterOnDownDelayCfg]),
+	dbRedisClusterDownDelay = cgrMigratorFlags.Duration(utils.RedisClusterOnDownDelayCfg, dfltCfg.DataDbCfg().Opts.RedisClusterOndownDelay,
 		"The delay before executing the commands if the redis cluster is in the CLUSTERDOWN state")
-	dbQueryTimeout = cgrMigratorFlags.String(utils.MongoQueryTimeoutCfg, utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.MongoQueryTimeoutCfg]),
+	dbQueryTimeout = cgrMigratorFlags.Duration(utils.MongoQueryTimeoutCfg, dfltCfg.DataDbCfg().Opts.MongoQueryTimeout,
 		"The timeout for queries")
 	dbRedisTls               = cgrMigratorFlags.Bool(utils.RedisTLSCfg, false, "Enable TLS when connecting to Redis")
 	dbRedisClientCertificate = cgrMigratorFlags.String(utils.RedisClientCertificateCfg, utils.EmptyString, "Path to the client certificate")
@@ -186,35 +186,33 @@ func main() {
 	if *inDBDataEncoding != dfltCfg.GeneralCfg().DBDataEncoding {
 		mgrCfg.GeneralCfg().DBDataEncoding = *inDBDataEncoding
 	}
-	if *inDataDBRedisSentinel != utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisSentinelNameCfg]) {
-		mgrCfg.DataDbCfg().Opts[utils.RedisSentinelNameCfg] = *inDataDBRedisSentinel
+	if *inDataDBRedisSentinel != dfltCfg.DataDbCfg().Opts.RedisSentinel {
+		mgrCfg.DataDbCfg().Opts.RedisSentinel = *inDataDBRedisSentinel
 	}
-	rdsCls, _ := utils.IfaceAsBool(dfltCfg.DataDbCfg().Opts[utils.RedisClusterCfg])
-	if *dbRedisCluster != rdsCls {
-		mgrCfg.DataDbCfg().Opts[utils.RedisClusterCfg] = *dbRedisCluster
+	if *dbRedisCluster != dfltCfg.DataDbCfg().Opts.RedisCluster {
+		mgrCfg.DataDbCfg().Opts.RedisCluster = *dbRedisCluster
 	}
-	if *dbRedisClusterSync != utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisClusterSyncCfg]) {
-		mgrCfg.DataDbCfg().Opts[utils.RedisClusterSyncCfg] = *dbRedisClusterSync
+	if *dbRedisClusterSync != dfltCfg.DataDbCfg().Opts.RedisClusterSync {
+		mgrCfg.DataDbCfg().Opts.RedisClusterSync = *dbRedisClusterSync
 	}
-	if *dbRedisClusterDownDelay != utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisClusterOnDownDelayCfg]) {
-		mgrCfg.DataDbCfg().Opts[utils.RedisClusterOnDownDelayCfg] = *dbRedisClusterDownDelay
+	if *dbRedisClusterDownDelay != dfltCfg.DataDbCfg().Opts.RedisClusterOndownDelay {
+		mgrCfg.DataDbCfg().Opts.RedisClusterOndownDelay = *dbRedisClusterDownDelay
 	}
-	if *dbQueryTimeout != utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.MongoQueryTimeoutCfg]) {
-		mgrCfg.DataDbCfg().Opts[utils.MongoQueryTimeoutCfg] = *dbQueryTimeout
+	if *dbQueryTimeout != dfltCfg.DataDbCfg().Opts.MongoQueryTimeout {
+		mgrCfg.DataDbCfg().Opts.MongoQueryTimeout = *dbQueryTimeout
 	}

-	rdsTLS, _ := utils.IfaceAsBool(dfltCfg.DataDbCfg().Opts[utils.RedisTLS])
-	if *dbRedisTls != rdsTLS {
-		mgrCfg.DataDbCfg().Opts[utils.RedisTLS] = *dbRedisTls
+	if *dbRedisTls != dfltCfg.DataDbCfg().Opts.RedisTLS {
+		mgrCfg.DataDbCfg().Opts.RedisTLS = *dbRedisTls
 	}
-	if *dbRedisClientCertificate != utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisClientCertificate]) {
-		mgrCfg.DataDbCfg().Opts[utils.RedisClientCertificate] = *dbRedisClientCertificate
+	if *dbRedisClientCertificate != dfltCfg.DataDbCfg().Opts.RedisClientCertificate {
+		mgrCfg.DataDbCfg().Opts.RedisClientCertificate = *dbRedisClientCertificate
 	}
-	if *dbRedisClientKey != utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisClientKey]) {
-		mgrCfg.DataDbCfg().Opts[utils.RedisClientKey] = *dbRedisClientKey
+	if *dbRedisClientKey != dfltCfg.DataDbCfg().Opts.RedisClientKey {
+		mgrCfg.DataDbCfg().Opts.RedisClientKey = *dbRedisClientKey
 	}
-	if *dbRedisCACertificate != utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisCACertificate]) {
-		mgrCfg.DataDbCfg().Opts[utils.RedisCACertificate] = *dbRedisCACertificate
+	if *dbRedisCACertificate != dfltCfg.DataDbCfg().Opts.RedisCACertificate {
+		mgrCfg.DataDbCfg().Opts.RedisCACertificate = *dbRedisCACertificate
 	}

 	// outDataDB
@@ -270,7 +268,7 @@ func main() {
 	}
 	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[utils.RedisSentinelNameCfg]
+			mgrCfg.MigratorCgrCfg().OutDataDBOpts[utils.RedisSentinelNameCfg] = dfltCfg.DataDbCfg().Opts.RedisSentinel
 		}
 	} else {
 		mgrCfg.MigratorCgrCfg().OutDataDBOpts[utils.RedisSentinelNameCfg] = *outDataDBRedisSentinel
--- a/config/configsanity.go
+++ b/config/configsanity.go
@@ -833,7 +833,7 @@ func (cfg *CGRConfig) checkConfigSanity() error {
 	if cfg.storDbCfg.Type == utils.Postgres {
 		if !utils.IsSliceMember([]string{utils.PostgressSSLModeDisable, utils.PostgressSSLModeAllow,
 			utils.PostgressSSLModePrefer, utils.PostgressSSLModeRequire, utils.PostgressSSLModeVerifyCa,
-			utils.PostgressSSLModeVerifyFull}, utils.IfaceAsString(cfg.storDbCfg.Opts[utils.SSLModeCfg])) {
+			utils.PostgressSSLModeVerifyFull}, cfg.storDbCfg.Opts.SSLMode) {
 			return fmt.Errorf("<%s> unsupported sslmode for storDB", utils.StorDB)
 		}
 	}
--- a/engine/storage_mysql.go
+++ b/engine/storage_mysql.go
@@ -32,7 +32,7 @@ type MySQLStorage struct {
 }

 func NewMySQLStorage(host, port, name, user, password string,
-	maxConn, maxIdleConn, connMaxLifetime int, location string) (*SQLStorage, error) {
+	maxConn, maxIdleConn int, connMaxLifetime time.Duration, location string) (*SQLStorage, error) {
 	connectString := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8&loc=%s&parseTime=true&sql_mode='ALLOW_INVALID_DATES'",
 		user, password, host, port, name, location)
 	db, err := gorm.Open(mysql.Open(connectString), &gorm.Config{AllowGlobalUpdate: true})
@@ -49,7 +49,7 @@ func NewMySQLStorage(host, port, name, user, password string,
 	}
 	mySQLStorage.DB.SetMaxIdleConns(maxIdleConn)
 	mySQLStorage.DB.SetMaxOpenConns(maxConn)
-	mySQLStorage.DB.SetConnMaxLifetime(time.Duration(connMaxLifetime) * time.Second)
+	mySQLStorage.DB.SetConnMaxLifetime(connMaxLifetime)
 	//db.LogMode(true)
 	mySQLStorage.db = db
 	return &SQLStorage{
--- a/engine/storage_postgres.go
+++ b/engine/storage_postgres.go
@@ -28,7 +28,7 @@ import (
 )

 // NewPostgresStorage returns the posgres storDB
-func NewPostgresStorage(host, port, name, user, password, sslmode string, maxConn, maxIdleConn, connMaxLifetime int) (*SQLStorage, error) {
+func NewPostgresStorage(host, port, name, user, password, sslmode string, maxConn, maxIdleConn int, connMaxLifetime time.Duration) (*SQLStorage, error) {
 	connectString := fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s sslmode=%s", host, port, name, user, password, sslmode)
 	db, err := gorm.Open(postgres.Open(connectString), &gorm.Config{AllowGlobalUpdate: true})
 	if err != nil {
@@ -43,7 +43,7 @@ func NewPostgresStorage(host, port, name, user, password, sslmode string, maxCon
 	}
 	postgressStorage.DB.SetMaxIdleConns(maxIdleConn)
 	postgressStorage.DB.SetMaxOpenConns(maxConn)
-	postgressStorage.DB.SetConnMaxLifetime(time.Duration(connMaxLifetime) * time.Second)
+	postgressStorage.DB.SetConnMaxLifetime(connMaxLifetime)
 	//db.LogMode(true)
 	postgressStorage.db = db
 	return &SQLStorage{
--- a/engine/storage_utils.go
+++ b/engine/storage_utils.go
@@ -22,8 +22,8 @@ import (
 	"fmt"
 	"strconv"
 	"strings"
-	"time"

+	"github.com/cgrates/cgrates/config"
 	"github.com/cgrates/cgrates/utils"
 )

@@ -31,7 +31,7 @@ import (

 // NewDataDBConn creates a DataDB connection
 func NewDataDBConn(dbType, host, port, name, user,
-	pass, marshaler string, opts map[string]interface{}) (d DataDBDriver, err error) {
+	pass, marshaler string, opts *config.DataDBOpts) (d DataDBDriver, err error) {
 	switch dbType {
 	case utils.Redis:
 		var dbNo int
@@ -43,33 +43,11 @@ func NewDataDBConn(dbType, host, port, name, user,
 		if port != "" && !strings.Contains(host, ":") {
 			host += ":" + port
 		}
-		var isCluster bool
-		if isCluster, err = utils.IfaceAsBool(opts[utils.RedisClusterCfg]); err != nil {
-			return
-		}
-		var clusterSync, clusterOnDownDelay time.Duration
-		if clusterSync, err = utils.IfaceAsDuration(opts[utils.RedisClusterSyncCfg]); err != nil {
-			return
-		}
-		if clusterOnDownDelay, err = utils.IfaceAsDuration(opts[utils.RedisClusterOnDownDelayCfg]); err != nil {
-			return
-		}
-		var hasTLSConn bool
-		if hasTLSConn, err = utils.IfaceAsBool(opts[utils.RedisTLSCfg]); err != nil {
-			return
-		}
-		d, err = NewRedisStorage(host, dbNo, user, pass, marshaler,
-			utils.RedisMaxConns, utils.RedisMaxAttempts, utils.IfaceAsString(opts[utils.RedisSentinelNameCfg]),
-			isCluster, clusterSync, clusterOnDownDelay, hasTLSConn,
-			utils.IfaceAsString(opts[utils.RedisClientCertificateCfg]),
-			utils.IfaceAsString(opts[utils.RedisClientKeyCfg]),
-			utils.IfaceAsString(opts[utils.RedisCACertificateCfg]))
+		d, err = NewRedisStorage(host, dbNo, user, pass, marshaler, utils.RedisMaxConns, utils.RedisMaxAttempts,
+			opts.RedisSentinel, opts.RedisCluster, opts.RedisClusterSync, opts.RedisClusterOndownDelay,
+			opts.RedisTLS, opts.RedisClientCertificate, opts.RedisClientKey, opts.RedisCACertificate)
 	case utils.Mongo:
-		var ttl time.Duration
-		if ttl, err = utils.IfaceAsDuration(opts[utils.MongoQueryTimeoutCfg]); err != nil {
-			return
-		}
-		d, err = NewMongoStorage(host, port, name, user, pass, marshaler, utils.DataDB, nil, ttl)
+		d, err = NewMongoStorage(host, port, name, user, pass, marshaler, utils.DataDB, nil, opts.MongoQueryTimeout)
 	case utils.Internal:
 		d = NewInternalDB(nil, nil, true)
 	default:
@@ -81,40 +59,16 @@ func NewDataDBConn(dbType, host, port, name, user,
 // NewStorDBConn returns a StorDB(implements Storage interface) based on dbType
 func NewStorDBConn(dbType, host, port, name, user, pass, marshaler string,
 	stringIndexedFields, prefixIndexedFields []string,
-	opts map[string]interface{}) (db StorDB, err error) {
+	opts *config.StorDBOpts) (db StorDB, err error) {
 	switch dbType {
 	case utils.Mongo:
-		var ttl time.Duration
-		if ttl, err = utils.IfaceAsDuration(opts[utils.MongoQueryTimeoutCfg]); err != nil {
-			return nil, err
-		}
-		db, err = NewMongoStorage(host, port, name, user, pass, marshaler, utils.StorDB, stringIndexedFields, ttl)
+		db, err = NewMongoStorage(host, port, name, user, pass, marshaler, utils.StorDB, stringIndexedFields, opts.MongoQueryTimeout)
 	case utils.Postgres:
-		var maxConn, maxIdleConn, connMaxLifetime int64
-		if maxConn, err = utils.IfaceAsTInt64(opts[utils.SQLMaxOpenConnsCfg]); err != nil {
-			return
-		}
-		if maxIdleConn, err = utils.IfaceAsTInt64(opts[utils.SQLMaxIdleConnsCfg]); err != nil {
-			return
-		}
-		if connMaxLifetime, err = utils.IfaceAsTInt64(opts[utils.SQLConnMaxLifetimeCfg]); err != nil {
-			return
-		}
-		db, err = NewPostgresStorage(host, port, name, user, pass, utils.IfaceAsString(opts[utils.SSLModeCfg]),
-			int(maxConn), int(maxIdleConn), int(connMaxLifetime))
+		db, err = NewPostgresStorage(host, port, name, user, pass, opts.SSLMode,
+			opts.SQLMaxOpenConns, opts.SQLMaxIdleConns, opts.SQLConnMaxLifetime)
 	case utils.MySQL:
-		var maxConn, maxIdleConn, connMaxLifetime int64
-		if maxConn, err = utils.IfaceAsTInt64(opts[utils.SQLMaxOpenConnsCfg]); err != nil {
-			return
-		}
-		if maxIdleConn, err = utils.IfaceAsTInt64(opts[utils.SQLMaxIdleConnsCfg]); err != nil {
-			return
-		}
-		if connMaxLifetime, err = utils.IfaceAsTInt64(opts[utils.SQLConnMaxLifetimeCfg]); err != nil {
-			return
-		}
-		db, err = NewMySQLStorage(host, port, name, user, pass, int(maxConn), int(maxIdleConn),
-			int(connMaxLifetime), utils.IfaceAsString(opts[utils.MysqlLocation]))
+		db, err = NewMySQLStorage(host, port, name, user, pass, opts.SQLMaxOpenConns, opts.SQLMaxIdleConns,
+			opts.SQLConnMaxLifetime, opts.MySQLLocation)
 	case utils.Internal:
 		db = NewInternalDB(stringIndexedFields, prefixIndexedFields, false)
 	default:
--- a/migrator/migrator_utils.go
+++ b/migrator/migrator_utils.go
@@ -33,7 +33,7 @@ var (

 func NewMigratorDataDB(db_type, host, port, name, user, pass,
 	marshaler string, cacheCfg *config.CacheCfg,
-	opts map[string]interface{}) (db MigratorDataDB, err error) {
+	opts *config.DataDBOpts) (db MigratorDataDB, err error) {
 	dbCon, err := engine.NewDataDBConn(db_type, host,
 		port, name, user, pass, marshaler, opts)
 	if err != nil {
@@ -59,8 +59,7 @@ func NewMigratorDataDB(db_type, host, port, name, user, pass,

 func NewMigratorStorDB(db_type, host, port, name, user, pass, marshaler string,
 	stringIndexedFields, prefixIndexedFields []string,
-	opts map[string]interface{}) (db MigratorStorDB, err error) {
-	var d MigratorStorDB
+	opts *config.StorDBOpts) (db MigratorStorDB, err error) {
 	storDb, err := engine.NewStorDBConn(db_type, host, port, name, user,
 		pass, marshaler, stringIndexedFields, prefixIndexedFields, opts)
 	if err != nil {
@@ -68,22 +67,18 @@ func NewMigratorStorDB(db_type, host, port, name, user, pass, marshaler string,
 	}
 	switch db_type {
 	case utils.Mongo:
-		d = newMongoStorDBMigrator(storDb)
-		db = d.(MigratorStorDB)
+		db = newMongoStorDBMigrator(storDb)
 	case utils.MySQL:
-		d = newMigratorSQL(storDb)
-		db = d.(MigratorStorDB)
+		db = newMigratorSQL(storDb)
 	case utils.Postgres:
-		d = newMigratorSQL(storDb)
-		db = d.(MigratorStorDB)
+		db = newMigratorSQL(storDb)
 	case utils.Internal:
-		d = newInternalStorDBMigrator(storDb)
-		db = d.(MigratorStorDB)
+		db = newInternalStorDBMigrator(storDb)
 	default:
 		err = fmt.Errorf("Unknown db '%s' valid options are [%s, %s, %s, %s]",
 			db_type, utils.MySQL, utils.Mongo, utils.Postgres, utils.Internal)
 	}
-	return d, nil
+	return
 }
 func (m *Migrator) getVersions(str string) (vrs engine.Versions, err error) {
 	if str == utils.CDRs || str == utils.SessionSCosts || strings.HasPrefix(str, "Tp") {
--- a/services/datadb.go
+++ b/services/datadb.go
@@ -21,7 +21,6 @@ package services
 import (
 	"fmt"
 	"sync"
-	"time"

 	"github.com/cgrates/birpc/context"
 	"github.com/cgrates/cgrates/config"
@@ -98,16 +97,12 @@ func (db *DataDBService) Reload(*context.Context, context.CancelFunc) (err error
 		return
 	}
 	if db.cfg.DataDbCfg().Type == utils.Mongo {
-		var ttl time.Duration
-		if ttl, err = utils.IfaceAsDuration(db.cfg.DataDbCfg().Opts[utils.MongoQueryTimeoutCfg]); err != nil {
-			return
-		}
 		mgo, canCast := db.dm.DataDB().(*engine.MongoStorage)
 		if !canCast {
 			return fmt.Errorf("can't conver DataDB of type %s to MongoStorage",
 				db.cfg.DataDbCfg().Type)
 		}
-		mgo.SetTTL(ttl)
+		mgo.SetTTL(db.cfg.DataDbCfg().Opts.MongoQueryTimeout)
 	}
 	return
 }
@@ -151,10 +146,10 @@ func (db *DataDBService) needsConnectionReload() bool {
 		return true
 	}
 	return db.oldDBCfg.Type == utils.Redis &&
-		(db.oldDBCfg.Opts[utils.RedisSentinelNameCfg] != db.cfg.DataDbCfg().Opts[utils.RedisSentinelNameCfg] ||
-			db.oldDBCfg.Opts[utils.RedisClusterCfg] != db.cfg.DataDbCfg().Opts[utils.RedisClusterCfg] ||
-			db.oldDBCfg.Opts[utils.RedisClusterSyncCfg] != db.cfg.DataDbCfg().Opts[utils.RedisClusterSyncCfg] ||
-			db.oldDBCfg.Opts[utils.RedisClusterOnDownDelayCfg] != db.cfg.DataDbCfg().Opts[utils.RedisClusterOnDownDelayCfg])
+		(db.oldDBCfg.Opts.RedisSentinel != db.cfg.DataDbCfg().Opts.RedisSentinel ||
+			db.oldDBCfg.Opts.RedisCluster != db.cfg.DataDbCfg().Opts.RedisCluster ||
+			db.oldDBCfg.Opts.RedisClusterSync != db.cfg.DataDbCfg().Opts.RedisClusterSync ||
+			db.oldDBCfg.Opts.RedisClusterOndownDelay != db.cfg.DataDbCfg().Opts.RedisClusterOndownDelay)
 }

 // GetDM returns the DataManager