Add set_versions flag to cgr-engine

If set to true, it sets/overwrites all versions to the
current ones.

cmd/cgr-engine/cgr-engine.go

@@ -66,6 +66,7 @@ var (
 	nodeID            = cgrEngineFlags.String(utils.NodeIDCfg, utils.EmptyString, "The node ID of the engine")
 	logLevel          = cgrEngineFlags.Int(utils.LogLevelCfg, -1, "Log level (0-emergency to 7-debug)")
 	preload           = cgrEngineFlags.String(utils.PreloadCgr, utils.EmptyString, "LoaderIDs used to load the data before the engine starts")
+	setVersions       = cgrEngineFlags.Bool("set_versions", false, "Overwrite database versions (equivalent to cgr-migrator -exec=*set_versions)")
 
 	cfg *config.CGRConfig
 )
@@ -538,7 +539,7 @@ func main() {
 	if err = gvService.Start(); err != nil {
 		log.Fatalf("<%s> error received: <%s>, exiting!", utils.InitS, err.Error())
 	}
-	dmService := services.NewDataDBService(cfg, connManager, srvDep)
+	dmService := services.NewDataDBService(cfg, connManager, *setVersions, srvDep)
 	if dmService.ShouldRun() { // Some services can run without db, ie:  ERs
 		shdWg.Add(1)
 		if err = dmService.Start(); err != nil {
@@ -546,7 +547,7 @@ func main() {
 		}
 	}
 
-	storDBService := services.NewStorDBService(cfg, srvDep)
+	storDBService := services.NewStorDBService(cfg, *setVersions, srvDep)
 	if storDBService.ShouldRun() { // Some services can run without db, ie:  ERs
 		shdWg.Add(1)
 		if err = storDBService.Start(); err != nil {

engine/version.go

@@ -61,31 +61,32 @@ func init() {
 // Versions will keep trac of various item versions
 type Versions map[string]int64 // map[item]versionNr
 
-// CheckVersions returns error if the db needs migration
+// CheckVersions returns an error if the db needs migration.
 func CheckVersions(storage Storage) error {
-	// get current db version
+
+	// Retrieve the current DB versions.
 	storType := storage.GetStorageType()
 	isDataDB := isDataDB(storage)
+	currentVersions := CurrentDBVersions(storType, isDataDB)
 
-	x := CurrentDBVersions(storType, isDataDB)
-	dbVersion, err := storage.GetVersions("")
+	dbVersions, err := storage.GetVersions("")
 	if err == utils.ErrNotFound {
 		empty, err := storage.IsDBEmpty()
 		if err != nil {
 			return err
 		}
 		if !empty {
-			return fmt.Errorf("No versions defined: please backup cgrates data and run : <cgr-migrator -exec=*set_versions>")
+			return fmt.Errorf("No versions defined: please backup cgrates data and run: <cgr-migrator -exec=*set_versions>")
 		}
-		// no data, safe to write version
+		// No data, safe to set the versions.
 		return OverwriteDBVersions(storage)
 	} else if err != nil {
 		return err
 	}
-	// comparing versions
-	message := dbVersion.Compare(x, storType, isDataDB)
+	// Compare db versions with current versions.
+	message := dbVersions.Compare(currentVersions, storType, isDataDB)
 	if message != "" {
-		return fmt.Errorf("Migration needed: please backup cgr data and run : <%s>", message)
+		return fmt.Errorf("Migration needed: please backup cgr data and run: <%s>", message)
 	}
 	return nil
 }

engine/version_test.go

@@ -277,7 +277,7 @@ func TestVersionCheckVersionsGetVersionsErrNotFoundNonEmptyDB(t *testing.T) {
 		testcase: "GetVersions ErrNotFound",
 	}
 
-	experr := "No versions defined: please backup cgrates data and run : <cgr-migrator -exec=*set_versions>"
+	experr := "No versions defined: please backup cgrates data and run: <cgr-migrator -exec=*set_versions>"
 	err := CheckVersions(storage)
 
 	if err == nil || err.Error() != experr {
@@ -303,11 +303,11 @@ func TestVersionCheckVersionsCompareNonNilMsg(t *testing.T) {
 		testcase: "Compare returns non-nil message",
 	}
 
-	experr := "Migration needed: please backup cgr data and run :"
+	experr := "Migration needed: please backup cgr data and run:"
 	err := CheckVersions(storage)
 
 	if err == nil || !strings.Contains(err.Error(), experr) {
-		t.Errorf("expected error to be of type: <Migration needed: please backup cgr data and run : ..., \n received: <%+v>", err)
+		t.Errorf("expected error to be of type: <Migration needed: please backup cgr data and run: ..., \n received: <%+v>", err)
 	}
 }
 

engine/z_versions_it_test.go

@@ -151,13 +151,13 @@ func testVersion(t *testing.T) {
 		currentVersion = allVersions
 		testVersion = allVersions
 		testVersion[utils.Accounts] = 1
-		test = "Migration needed: please backup cgr data and run : <cgr-migrator -exec=*accounts>"
+		test = "Migration needed: please backup cgr data and run: <cgr-migrator -exec=*accounts>"
 	case utils.MetaMongo, utils.MetaRedis:
 		currentVersion = dataDbVersions
 		testVersion = dataDbVersions
 		testVersion[utils.Accounts] = 1
 
-		test = "Migration needed: please backup cgr data and run : <cgr-migrator -exec=*accounts>"
+		test = "Migration needed: please backup cgr data and run: <cgr-migrator -exec=*accounts>"
 	}
 
 	//dataDB
@@ -193,12 +193,12 @@ func testVersion(t *testing.T) {
 		currentVersion = allVersions
 		testVersion = allVersions
 		testVersion[utils.Accounts] = 1
-		test = "Migration needed: please backup cgr data and run : <cgr-migrator -exec=*accounts>"
+		test = "Migration needed: please backup cgr data and run: <cgr-migrator -exec=*accounts>"
 	case utils.MetaMongo, utils.MetaPostgres, utils.MetaMySQL:
 		currentVersion = storDbVersions
 		testVersion = allVersions
 		testVersion[utils.CostDetails] = 1
-		test = "Migration needed: please backup cgr data and run : <cgr-migrator -exec=*cost_details>"
+		test = "Migration needed: please backup cgr data and run: <cgr-migrator -exec=*cost_details>"
 	}
 	//storageDb
 
@@ -274,7 +274,7 @@ func testUpdateVersionsAccounts(t *testing.T) {
 		t.Log(output.String())
 		t.Fatalf("expected: %s, \nreceived: %s", "exit status 1", err)
 	}
-	errExpect := "Migration needed: please backup cgr data and run : <cgr-migrator -exec=*accounts>"
+	errExpect := "Migration needed: please backup cgr data and run: <cgr-migrator -exec=*accounts>"
 	if !strings.Contains(output.String(), errExpect) {
 		t.Errorf("expected %s \nto contain: %s", output.String(), errExpect)
 	}
@@ -295,7 +295,7 @@ func testUpdateVersionsActionPlans(t *testing.T) {
 		t.Log(output.String())
 		t.Fatalf("expected: %s, \nreceived: %s", "exit status 1", err)
 	}
-	errExpect := "Migration needed: please backup cgr data and run : <cgr-migrator -exec=*action_plans>"
+	errExpect := "Migration needed: please backup cgr data and run: <cgr-migrator -exec=*action_plans>"
 	if !strings.Contains(output.String(), errExpect) {
 		t.Errorf("expected %s \nto contain: %s", output.String(), errExpect)
 	}
@@ -316,7 +316,7 @@ func testUpdateVersionsActionTriggers(t *testing.T) {
 		t.Log(output.String())
 		t.Fatalf("expected: %s, \nreceived: %s", "exit status 1", err)
 	}
-	errExpect := "Migration needed: please backup cgr data and run : <cgr-migrator -exec=*action_triggers>"
+	errExpect := "Migration needed: please backup cgr data and run: <cgr-migrator -exec=*action_triggers>"
 	if !strings.Contains(output.String(), errExpect) {
 		t.Errorf("expected %s \nto contain: %s", output.String(), errExpect)
 	}
@@ -337,7 +337,7 @@ func testUpdateVersionsActions(t *testing.T) {
 		t.Log(output.String())
 		t.Fatalf("expected: %s, \nreceived: %s", "exit status 1", err)
 	}
-	errExpect := "Migration needed: please backup cgr data and run : <cgr-migrator -exec=*actions>"
+	errExpect := "Migration needed: please backup cgr data and run: <cgr-migrator -exec=*actions>"
 	if !strings.Contains(output.String(), errExpect) {
 		t.Errorf("expected %s \nto contain: %s", output.String(), errExpect)
 	}
@@ -358,7 +358,7 @@ func testUpdateVersionsChargers(t *testing.T) {
 		t.Log(output.String())
 		t.Fatalf("expected: %s, \nreceived: %s", "exit status 1", err)
 	}
-	errExpect := "Migration needed: please backup cgr data and run : <cgr-migrator -exec=*chargers>"
+	errExpect := "Migration needed: please backup cgr data and run: <cgr-migrator -exec=*chargers>"
 	if !strings.Contains(output.String(), errExpect) {
 		t.Errorf("expected %s \nto contain: %s", output.String(), errExpect)
 	}
@@ -398,7 +398,7 @@ func testUpdateVersionsAttributes(t *testing.T) {
 		t.Log(output.String())
 		t.Fatalf("expected: %s, \nreceived: %s", "exit status 1", err)
 	}
-	errExpect := "Migration needed: please backup cgr data and run : <cgr-migrator -exec=*attributes>"
+	errExpect := "Migration needed: please backup cgr data and run: <cgr-migrator -exec=*attributes>"
 	if !strings.Contains(output.String(), errExpect) {
 		t.Errorf("expected %s \nto contain: %s", output.String(), errExpect)
 	}
@@ -419,7 +419,7 @@ func testUpdateVersionsDispatchers(t *testing.T) {
 		t.Log(output.String())
 		t.Fatalf("expected: %s, \nreceived: %s", "exit status 1", err)
 	}
-	errExpect := "Migration needed: please backup cgr data and run : <cgr-migrator -exec=*dispatchers>"
+	errExpect := "Migration needed: please backup cgr data and run: <cgr-migrator -exec=*dispatchers>"
 	if !strings.Contains(output.String(), errExpect) {
 		t.Errorf("expected %s \nto contain: %s", output.String(), errExpect)
 	}
@@ -460,7 +460,7 @@ func testUpdateVersionsRQF(t *testing.T) {
 		t.Log(output.String())
 		t.Fatalf("expected: %s, \nreceived: %s", "exit status 1", err)
 	}
-	errExpect := "Migration needed: please backup cgr data and run : <cgr-migrator -exec=*filters>"
+	errExpect := "Migration needed: please backup cgr data and run: <cgr-migrator -exec=*filters>"
 	if !strings.Contains(output.String(), errExpect) {
 		t.Errorf("expected %s \nto contain: %s", output.String(), errExpect)
 	}
@@ -561,7 +561,7 @@ func testUpdateVersionsRoutes(t *testing.T) {
 		t.Log(output.String())
 		t.Fatalf("expected: %s, \nreceived: %s", "exit status 1", err)
 	}
-	errExpect := "Migration needed: please backup cgr data and run : <cgr-migrator -exec=*routes>"
+	errExpect := "Migration needed: please backup cgr data and run: <cgr-migrator -exec=*routes>"
 	if !strings.Contains(output.String(), errExpect) {
 		t.Errorf("expected %s \nto contain: %s", output.String(), errExpect)
 	}
@@ -582,7 +582,7 @@ func testUpdateVersionsSharedGroups(t *testing.T) {
 		t.Log(output.String())
 		t.Fatalf("expected: %s, \nreceived: %s", "exit status 1", err)
 	}
-	errExpect := "Migration needed: please backup cgr data and run : <cgr-migrator -exec=*shared_groups>"
+	errExpect := "Migration needed: please backup cgr data and run: <cgr-migrator -exec=*shared_groups>"
 	if !strings.Contains(output.String(), errExpect) {
 		t.Errorf("expected %s \nto contain: %s", output.String(), errExpect)
 	}
@@ -603,7 +603,7 @@ func testUpdateVersionsStats(t *testing.T) {
 		t.Log(output.String())
 		t.Fatalf("expected: %s, \nreceived: %s", "exit status 1", err)
 	}
-	errExpect := "Migration needed: please backup cgr data and run : <cgr-migrator -exec=*stats>"
+	errExpect := "Migration needed: please backup cgr data and run: <cgr-migrator -exec=*stats>"
 	if !strings.Contains(output.String(), errExpect) {
 		t.Errorf("expected %s \nto contain: %s", output.String(), errExpect)
 	}
@@ -644,7 +644,7 @@ func testUpdateVersionsThresholds(t *testing.T) {
 		t.Log(output.String())
 		t.Fatalf("expected: %s, \nreceived: %s", "exit status 1", err)
 	}
-	errExpect := "Migration needed: please backup cgr data and run : <cgr-migrator -exec=*thresholds>"
+	errExpect := "Migration needed: please backup cgr data and run: <cgr-migrator -exec=*thresholds>"
 	if !strings.Contains(output.String(), errExpect) {
 		t.Errorf("expected %s \nto contain: %s", output.String(), errExpect)
 	}
@@ -686,7 +686,7 @@ func testUpdateVersionsCostDetails(t *testing.T) {
 		t.Log(output.String())
 		t.Fatalf("expected: %s, \nreceived: %s", "exit status 1", err)
 	}
-	errExpect := "Migration needed: please backup cgr data and run : <cgr-migrator -exec=*cost_details>"
+	errExpect := "Migration needed: please backup cgr data and run: <cgr-migrator -exec=*cost_details>"
 	if !strings.Contains(output.String(), errExpect) {
 		t.Errorf("expected %s \nto contain: %s", output.String(), errExpect)
 	}
@@ -707,7 +707,7 @@ func testUpdateVersionsSessionSCosts(t *testing.T) {
 		t.Log(output.String())
 		t.Fatalf("expected: %s, \nreceived: %s", "exit status 1", err)
 	}
-	errExpect := "Migration needed: please backup cgr data and run : <cgr-migrator -exec=*sessions_costs>"
+	errExpect := "Migration needed: please backup cgr data and run: <cgr-migrator -exec=*sessions_costs>"
 	if !strings.Contains(output.String(), errExpect) {
 		t.Errorf("expected %s \nto contain: %s", output.String(), errExpect)
 	}
@@ -728,7 +728,7 @@ func testUpdateVersionsCDRs(t *testing.T) {
 		t.Log(output.String())
 		t.Fatalf("expected: %s, \nreceived: %s", "exit status 1", err)
 	}
-	errExpect := "Migration needed: please backup cgr data and run : <cgr-migrator -exec=*cdrs>"
+	errExpect := "Migration needed: please backup cgr data and run: <cgr-migrator -exec=*cdrs>"
 	if !strings.Contains(output.String(), errExpect) {
 		t.Errorf("expected %s \nto contain: %s", output.String(), errExpect)
 	}

services/analyzers_it_test.go

@@ -52,7 +52,7 @@ func TestAnalyzerSReload(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	anzRPC := make(chan birpc.ClientConnector, 1)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, anzRPC, srvDep)
 	engine.NewConnManager(cfg, nil)

services/apiers_it_test.go

@@ -58,9 +58,9 @@ func TestApiersReload(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	cfg.StorDbCfg().Type = utils.MetaInternal
-	stordb := NewStorDBService(cfg, srvDep)
+	stordb := NewStorDBService(cfg, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	schS := NewSchedulerService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep)
 	tS := NewThresholdService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), anz, srvDep)

services/apiers_test.go

@@ -44,9 +44,9 @@ func TestApiersCoverage(t *testing.T) {
 	cfg.SchedulerCfg().Enabled = true
 	server := cores.NewServer(nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	cfg.StorDbCfg().Type = utils.MetaInternal
-	stordb := NewStorDBService(cfg, srvDep)
+	stordb := NewStorDBService(cfg, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	schS := NewSchedulerService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep)
 	apiSv1 := NewAPIerSv1Service(cfg, db, stordb, filterSChan, server, schS, new(ResponderService),

services/asteriskagent_it_test.go

@@ -66,7 +66,7 @@ func TestAsteriskAgentReload(t *testing.T) {
 	})
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, cm)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, cm, srvDep)
+	db := NewDataDBService(cfg, cm, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	sS := NewSessionService(cfg, db, server, make(chan birpc.ClientConnector, 1),
 		shdChan, cm, anz, srvDep)
@@ -139,7 +139,7 @@ func TestAsteriskAgentReload2(t *testing.T) {
 	})
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, cm)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, cm, srvDep)
+	db := NewDataDBService(cfg, cm, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	sS := NewSessionService(cfg, db, server, make(chan birpc.ClientConnector, 1),
 		shdChan, cm, anz, srvDep)

services/attributes_it_test.go

@@ -51,7 +51,7 @@ func TestAttributeSReload(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	attrRPC := make(chan birpc.ClientConnector, 1)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	attrS := NewAttributeService(cfg, db,

services/attributes_test.go

@@ -39,7 +39,7 @@ func TestAttributeSCoverage(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	attrRPC := make(chan birpc.ClientConnector, 1)
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	attrS := NewAttributeService(cfg, db, chS, filterSChan, server, attrRPC, anz, srvDep)
 	if attrS == nil {

services/cdrs_it_test.go

@@ -64,9 +64,9 @@ func TestCdrsReload(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	cfg.StorDbCfg().Type = utils.MetaInternal
-	stordb := NewStorDBService(cfg, srvDep)
+	stordb := NewStorDBService(cfg, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	chrS := NewChargerService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep)
 	schS := NewSchedulerService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep)

services/cdrs_test.go

@@ -40,9 +40,9 @@ func TestCdrsCoverage(t *testing.T) {
 	cfg.ChargerSCfg().Enabled = true
 	server := cores.NewServer(nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	cfg.StorDbCfg().Type = utils.MetaInternal
-	stordb := NewStorDBService(cfg, srvDep)
+	stordb := NewStorDBService(cfg, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	cdrsRPC := make(chan birpc.ClientConnector, 1)
 	cdrS := NewCDRServer(cfg, db, stordb, filterSChan, server,

services/chargers_it_test.go

@@ -53,7 +53,7 @@ func TestChargerSReload(t *testing.T) {
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	server := cores.NewServer(nil)
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	attrS := NewAttributeService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), anz, srvDep)
 	chrS := NewChargerService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep)

services/chargers_test.go

@@ -39,7 +39,7 @@ func TestChargerSCoverage(t *testing.T) {
 	filterSChan <- nil
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	server := cores.NewServer(nil)
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	chrS1 := NewChargerService(cfg, db, chS,
 		filterSChan, server, make(chan birpc.ClientConnector, 1),

services/cores_it_test.go

@@ -48,7 +48,7 @@ func TestCoreSReload(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	coreRPC := make(chan birpc.ClientConnector, 1)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	caps := engine.NewCaps(1, "test_caps")

services/datadb.go

@@ -28,13 +28,14 @@ import (
 )
 
 // NewDataDBService returns the DataDB Service
-func NewDataDBService(cfg *config.CGRConfig, connMgr *engine.ConnManager,
+func NewDataDBService(cfg *config.CGRConfig, connMgr *engine.ConnManager, setVersions bool,
 	srvDep map[string]*sync.WaitGroup) *DataDBService {
 	return &DataDBService{
-		cfg:     cfg,
-		dbchan:  make(chan *engine.DataManager, 1),
-		connMgr: connMgr,
-		srvDep:  srvDep,
+		cfg:         cfg,
+		dbchan:      make(chan *engine.DataManager, 1),
+		connMgr:     connMgr,
+		setVersions: setVersions,
+		srvDep:      srvDep,
 	}
 }
 
@@ -45,12 +46,14 @@ type DataDBService struct {
 	oldDBCfg *config.DataDbCfg
 	connMgr  *engine.ConnManager
 
-	dm     *engine.DataManager
-	dbchan chan *engine.DataManager
+	dm          *engine.DataManager
+	dbchan      chan *engine.DataManager
+	setVersions bool
+
 	srvDep map[string]*sync.WaitGroup
 }
 
-// Start should handle the sercive start
+// Start handles the service start.
 func (db *DataDBService) Start() (err error) {
 	if db.IsRunning() {
 		return utils.ErrServiceAlreadyRunning
@@ -58,24 +61,31 @@ func (db *DataDBService) Start() (err error) {
 	db.Lock()
 	defer db.Unlock()
 	db.oldDBCfg = db.cfg.DataDbCfg().Clone()
-	d, err := engine.NewDataDBConn(db.cfg.DataDbCfg().Type,
+	dbConn, err := engine.NewDataDBConn(db.cfg.DataDbCfg().Type,
 		db.cfg.DataDbCfg().Host, db.cfg.DataDbCfg().Port,
 		db.cfg.DataDbCfg().Name, db.cfg.DataDbCfg().User,
 		db.cfg.DataDbCfg().Password, db.cfg.GeneralCfg().DBDataEncoding,
 		db.cfg.DataDbCfg().Opts, db.cfg.DataDbCfg().Items)
-	if db.mandatoryDB() && err != nil { // Cannot configure getter database, show stopper
+	if db.mandatoryDB() && err != nil { // cannot configure mandatory database
 		utils.Logger.Crit(fmt.Sprintf("Could not configure dataDb: %s exiting!", err))
 		return
 	} else if db.cfg.SessionSCfg().Enabled && err != nil {
 		utils.Logger.Warning(fmt.Sprintf("Could not configure dataDb: %s. Some SessionS APIs will not work", err))
-		err = nil // reset the error in case of only SessionS active
+		err = nil // reset the error only if SessionS is enabled
 		return
 	}
-	db.dm = engine.NewDataManager(d, db.cfg.CacheCfg(), db.connMgr)
+	db.dm = engine.NewDataManager(dbConn, db.cfg.CacheCfg(), db.connMgr)
 	engine.SetDataStorage(db.dm)
-	if err = engine.CheckVersions(db.dm.DataDB()); err != nil {
+
+	if db.setVersions {
+		err = engine.OverwriteDBVersions(dbConn)
+	} else {
+		err = engine.CheckVersions(db.dm.DataDB())
+	}
+	if err != nil {
 		return err
 	}
+
 	db.dbchan <- db.dm
 	return
 }

services/datadb_it_test.go

@@ -53,7 +53,7 @@ func TestDataDBReload(t *testing.T) {
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	cM := engine.NewConnManager(cfg, nil)
-	db := NewDataDBService(cfg, cM, srvDep)
+	db := NewDataDBService(cfg, cM, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	srvMngr.AddServices(NewAttributeService(cfg, db,
 		chS, filterSChan, server, make(chan birpc.ClientConnector, 1), anz, srvDep),
@@ -214,7 +214,7 @@ func TestDataDBReloadBadType(t *testing.T) {
 	filterSChan <- nil
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	cM := engine.NewConnManager(cfg, nil)
-	db := NewDataDBService(cfg, cM, srvDep)
+	db := NewDataDBService(cfg, cM, false, srvDep)
 	db.oldDBCfg = &config.DataDbCfg{
 		Type: utils.MetaMongo,
 		Host: "127.0.0.1",
@@ -333,7 +333,7 @@ func TestDataDBReloadErrorMarsheler(t *testing.T) {
 	filterSChan <- nil
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	cM := engine.NewConnManager(cfg, nil)
-	db := NewDataDBService(cfg, cM, srvDep)
+	db := NewDataDBService(cfg, cM, false, srvDep)
 
 	if db.IsRunning() {
 		t.Errorf("Expected service to be down")
@@ -495,10 +495,10 @@ func TestDataDBStartVersion(t *testing.T) {
 	filterSChan <- nil
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	cM := engine.NewConnManager(cfg, nil)
-	db := NewDataDBService(cfg, cM, srvDep)
+	db := NewDataDBService(cfg, cM, false, srvDep)
 	err = db.Start()
-	if err == nil || err.Error() != "Migration needed: please backup cgr data and run : <cgr-migrator -exec=*attributes>" {
-		t.Errorf("\nExpecting <%+v>,\n Received <%+v>", "Migration needed: please backup cgr data and run : <cgr-migrator -exec=*attributes>", err)
+	if err == nil || err.Error() != "Migration needed: please backup cgr data and run: <cgr-migrator -exec=*attributes>" {
+		t.Errorf("\nExpecting <%+v>,\n Received <%+v>", "Migration needed: please backup cgr data and run: <cgr-migrator -exec=*attributes>", err)
 	}
 	shdChan.CloseOnce()
 	time.Sleep(10 * time.Millisecond)
@@ -555,7 +555,7 @@ func TestDataDBReloadCastError(t *testing.T) {
 	filterSChan <- nil
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	cM := engine.NewConnManager(cfg, nil)
-	db := NewDataDBService(cfg, cM, srvDep)
+	db := NewDataDBService(cfg, cM, false, srvDep)
 	db.oldDBCfg = &config.DataDbCfg{
 		Type: utils.MetaMongo,
 		Host: "127.0.0.1",
@@ -668,7 +668,7 @@ func TestDataDBStartSessionSCfgErr(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	cM := engine.NewConnManager(cfg, nil)
-	db := NewDataDBService(cfg, cM, srvDep)
+	db := NewDataDBService(cfg, cM, false, srvDep)
 	cfg.DataDbCfg().Type = "badtype"
 	cfg.SessionSCfg().Enabled = true
 	cfg.SessionSCfg().ListenBijson = ""
@@ -682,7 +682,7 @@ func TestDataDBStartRalsSCfgErr(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	cM := engine.NewConnManager(cfg, nil)
-	db := NewDataDBService(cfg, cM, srvDep)
+	db := NewDataDBService(cfg, cM, false, srvDep)
 	cfg.DataDbCfg().Type = "badtype"
 	db.cfg.RalsCfg().Enabled = true
 	cfg.SessionSCfg().ListenBijson = ""
@@ -696,7 +696,7 @@ func TestDataDBReloadError(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	cM := engine.NewConnManager(cfg, nil)
-	db := NewDataDBService(cfg, cM, srvDep)
+	db := NewDataDBService(cfg, cM, false, srvDep)
 	cfg.GeneralCfg().DBDataEncoding = utils.JSON
 	db.oldDBCfg = &config.DataDbCfg{
 		Type: utils.MetaMongo,

services/datadb_test.go

@@ -36,7 +36,7 @@ func TestDataDBCoverage(t *testing.T) {
 	filterSChan <- nil
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	cM := engine.NewConnManager(cfg, nil)
-	db := NewDataDBService(cfg, cM, srvDep)
+	db := NewDataDBService(cfg, cM, false, srvDep)
 	if db.IsRunning() {
 		t.Errorf("Expected service to be down")
 	}

services/diameteragent_it_test.go

@@ -55,7 +55,7 @@ func TestDiameterAgentReload1(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	sS := NewSessionService(cfg, db, server, make(chan birpc.ClientConnector, 1),
 		shdChan, nil, anz, srvDep)

services/dispatchers_it_test.go

@@ -54,7 +54,7 @@ func TestDispatcherSReload(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	attrS := NewAttributeService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), anz, srvDep)
 	srv := NewDispatcherService(cfg, db, chS, filterSChan, server,

services/dispatchers_test.go

@@ -40,7 +40,7 @@ func TestDispatcherSCoverage(t *testing.T) {
 	filterSChan <- nil
 	server := cores.NewServer(nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	srv := NewDispatcherService(cfg, db, chS, filterSChan, server,
 		make(chan birpc.ClientConnector, 1), nil, anz, srvDep)

services/dnsagent_it_test.go

@@ -62,7 +62,7 @@ func TestDNSAgentStartReloadShut(t *testing.T) {
 	shdWg := new(sync.WaitGroup)
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	engine.NewConnManager(cfg, nil)
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	server := cores.NewServer(nil)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	sS := NewSessionService(cfg, db, server, make(chan birpc.ClientConnector, 1),
@@ -118,7 +118,7 @@ func TestDNSAgentReloadFirst(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	sS := NewSessionService(cfg, db, server, make(chan birpc.ClientConnector, 1),
 		shdChan, nil, anz, srvDep)

services/ees_it_test.go

@@ -58,7 +58,7 @@ func TestEventExporterSReload(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	chS := engine.NewCacheS(cfg, nil, nil)
 	close(chS.GetPrecacheChannel(utils.CacheAttributeProfiles))
 	close(chS.GetPrecacheChannel(utils.CacheAttributeFilterIndexes))

services/ers_it_test.go

@@ -65,7 +65,7 @@ func TestEventReaderSReload(t *testing.T) {
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	sS := NewSessionService(cfg, db, server, make(chan birpc.ClientConnector, 1), shdChan, nil, anz, srvDep)
 	intERsConn := make(chan birpc.ClientConnector, 1)
 	erS := NewEventReaderService(cfg, filterSChan, shdChan, nil, server, intERsConn, anz, srvDep)

services/freeswitchagent_it_test.go

@@ -67,7 +67,7 @@ func TestFreeSwitchAgentReload(t *testing.T) {
 	})
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, cm)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, cm, srvDep)
+	db := NewDataDBService(cfg, cm, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	sS := NewSessionService(cfg, db, server, make(chan birpc.ClientConnector, 1),
 		shdChan, cm, anz, srvDep)

services/httpagent_it_test.go

@@ -60,7 +60,7 @@ func TestHTTPAgentReload(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	sS := NewSessionService(cfg, db, server, make(chan birpc.ClientConnector, 1),
 		shdChan, nil, anz, srvDep)

services/kamailioagent_it_test.go

@@ -60,7 +60,7 @@ func TestKamailioAgentReload(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	sS := NewSessionService(cfg, db, server, make(chan birpc.ClientConnector, 1),
 		shdChan, nil, anz, srvDep)

services/loaders_it_test.go

@@ -72,7 +72,7 @@ func TestLoaderSReload(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	conMngr := engine.NewConnManager(cfg, nil)
 	srv := NewLoaderService(cfg, db, filterSChan,
@@ -154,7 +154,7 @@ func TestLoaderSReload2(t *testing.T) {
 	filterSChan <- nil
 	server := cores.NewServer(nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	db.dbchan <- new(engine.DataManager)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	srv := NewLoaderService(cfg, db, filterSChan,
@@ -179,7 +179,7 @@ func TestLoaderSReload3(t *testing.T) {
 	filterSChan <- nil
 	server := cores.NewServer(nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	db.dbchan <- new(engine.DataManager)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	srv := NewLoaderService(cfg, db, filterSChan,

services/loaders_test.go

@@ -39,7 +39,7 @@ func TestLoaderSCoverage(t *testing.T) {
 	filterSChan <- nil
 	server := cores.NewServer(nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	internalLoaderSChan := make(chan birpc.ClientConnector, 1)
 	rpcInternal := map[string]chan birpc.ClientConnector{}
 	cM := engine.NewConnManager(cfg, rpcInternal)

services/radiusagent_it_test.go

@@ -64,7 +64,7 @@ func TestRadiusAgentReloadStartShut(t *testing.T) {
 	shdWg := new(sync.WaitGroup)
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	engine.NewConnManager(cfg, nil)
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	server := cores.NewServer(nil)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	sS := NewSessionService(cfg, db, server, make(chan birpc.ClientConnector, 1),
@@ -120,7 +120,7 @@ func TestRadiusAgentReload1(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	sS := NewSessionService(cfg, db, server, make(chan birpc.ClientConnector, 1),
 		shdChan, nil, anz, srvDep)
@@ -191,7 +191,7 @@ func TestRadiusAgentReload2(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	sS := NewSessionService(cfg, db, server, make(chan birpc.ClientConnector, 1),
 		shdChan, nil, anz, srvDep)

services/rals_it_test.go

@@ -64,10 +64,10 @@ func TestRalsReload(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	cfg.StorDbCfg().Type = utils.MetaInternal
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
-	stordb := NewStorDBService(cfg, srvDep)
+	stordb := NewStorDBService(cfg, false, srvDep)
 	schS := NewSchedulerService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep)
 	tS := NewThresholdService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), anz, srvDep)
 	ralS := NewRalService(cfg, chS, server,

services/registrarc_it_test.go

@@ -55,7 +55,7 @@ func TestDispatcherHReload(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	connMngr := engine.NewConnManager(cfg, nil)
 	srv := NewRegistrarCService(cfg, server, connMngr, anz, srvDep)

services/resources_it_test.go

@@ -57,7 +57,7 @@ func TestResourceSReload(t *testing.T) {
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	tS := NewThresholdService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), anz, srvDep)
 	reS := NewResourceService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep)
 	engine.NewConnManager(cfg, nil)

services/resources_test.go

@@ -40,7 +40,7 @@ func TestResourceSCoverage(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	reS := NewResourceService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep)
 
 	if reS.IsRunning() {

services/routes_it_test.go

@@ -52,7 +52,7 @@ func TestRouteSReload(t *testing.T) {
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	routeS := NewRouteService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep)
 	engine.NewConnManager(cfg, nil)
 	srvMngr.AddServices(routeS,

services/routes_test.go

@@ -39,7 +39,7 @@ func TestSupplierSCoverage(t *testing.T) {
 	chS := engine.NewCacheS(cfg, nil, nil)
 	server := cores.NewServer(nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	supS := NewRouteService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep)
 

services/schedulers_it_test.go

@@ -50,7 +50,7 @@ func TestSchedulerSReload(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	schS := NewSchedulerService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep)
 	engine.NewConnManager(cfg, nil)

services/schedulers_test.go

@@ -41,7 +41,7 @@ func TestSchedulerSCoverage(t *testing.T) {
 	close(chS.GetPrecacheChannel(utils.CacheActionPlans))
 	server := cores.NewServer(nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	schS := NewSchedulerService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep)
 

services/sessions_it_test.go

@@ -101,7 +101,7 @@ func TestSessionSReload1(t *testing.T) {
 		utils.ConcatenatedKey(utils.MetaInternal, utils.MetaChargers): clientConect,
 	})
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
-	dmService := NewDataDBService(cfg, conMng, srvDep)
+	dmService := NewDataDBService(cfg, conMng, false, srvDep)
 	if err := dmService.Start(); err != nil {
 		t.Fatal(err)
 	}
@@ -177,7 +177,7 @@ func TestSessionSReload2(t *testing.T) {
 	server := cores.NewServer(nil)
 
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	cfg.StorDbCfg().Type = utils.MetaInternal
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	srv := NewSessionService(cfg, db, server, make(chan birpc.ClientConnector, 1), shdChan, nil, anz, srvDep)
@@ -241,7 +241,7 @@ func TestSessionSReload3(t *testing.T) {
 	server := cores.NewServer(nil)
 
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	cfg.StorDbCfg().Type = utils.MetaInternal
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	srv := NewSessionService(cfg, db, server, make(chan birpc.ClientConnector, 1), shdChan, nil, anz, srvDep)

services/sessions_test.go

@@ -51,7 +51,7 @@ func TestSessionSCoverage(t *testing.T) {
 	cacheSChan <- cacheSrv
 	server := cores.NewServer(nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	cfg.StorDbCfg().Type = utils.MetaInternal
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	srv := NewSessionService(cfg, db, server, make(chan birpc.ClientConnector, 1), shdChan, nil, anz, srvDep)

services/sipagent_it_test.go

@@ -58,7 +58,7 @@ func TestSIPAgentReload(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	sS := NewSessionService(cfg, db, server, make(chan birpc.ClientConnector, 1),
 		shdChan, nil, anz, srvDep)

services/stats_it_test.go

@@ -57,7 +57,7 @@ func TestStatSReload(t *testing.T) {
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	tS := NewThresholdService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), anz, srvDep)
 	sS := NewStatService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep)
 	engine.NewConnManager(cfg, nil)

services/stats_test.go

@@ -41,7 +41,7 @@ func TestStatSCoverage(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	sS := NewStatService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep)
 	if sS.IsRunning() {
 		t.Errorf("Expected service to be down")

services/stordb.go

@@ -28,11 +28,12 @@ import (
 )
 
 // NewStorDBService returns the StorDB Service
-func NewStorDBService(cfg *config.CGRConfig,
+func NewStorDBService(cfg *config.CGRConfig, setVersions bool,
 	srvDep map[string]*sync.WaitGroup) *StorDBService {
 	return &StorDBService{
-		cfg:    cfg,
-		srvDep: srvDep,
+		cfg:         cfg,
+		setVersions: setVersions,
+		srvDep:      srvDep,
 	}
 }
 
@@ -42,8 +43,9 @@ type StorDBService struct {
 	cfg      *config.CGRConfig
 	oldDBCfg *config.StorDbCfg
 
-	db        engine.StorDB
-	syncChans []chan engine.StorDB
+	db          engine.StorDB
+	syncChans   []chan engine.StorDB
+	setVersions bool
 
 	srvDep map[string]*sync.WaitGroup
 }
@@ -56,7 +58,7 @@ func (db *StorDBService) Start() (err error) {
 	db.Lock()
 	defer db.Unlock()
 	db.oldDBCfg = db.cfg.StorDbCfg().Clone()
-	d, err := engine.NewStorDBConn(db.cfg.StorDbCfg().Type, db.cfg.StorDbCfg().Host,
+	dbConn, err := engine.NewStorDBConn(db.cfg.StorDbCfg().Type, db.cfg.StorDbCfg().Host,
 		db.cfg.StorDbCfg().Port, db.cfg.StorDbCfg().Name, db.cfg.StorDbCfg().User,
 		db.cfg.StorDbCfg().Password, db.cfg.GeneralCfg().DBDataEncoding,
 		db.cfg.StorDbCfg().StringIndexedFields, db.cfg.StorDbCfg().PrefixIndexedFields,
@@ -65,12 +67,18 @@ func (db *StorDBService) Start() (err error) {
 		utils.Logger.Crit(fmt.Sprintf("Could not configure storDB: %s exiting!", err))
 		return
 	}
-	db.db = d
+	db.db = dbConn
 	engine.SetCdrStorage(db.db)
-	if err = engine.CheckVersions(db.db); err != nil {
-		fmt.Println(err)
-		return
+
+	if db.setVersions {
+		err = engine.OverwriteDBVersions(dbConn)
+	} else {
+		err = engine.CheckVersions(db.db)
 	}
+	if err != nil {
+		return err
+	}
+
 	db.sync()
 	return
 }

services/stordb_it_test.go

@@ -48,9 +48,9 @@ func TestStorDBReload(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	cfg.StorDbCfg().Password = "CGRateS.org"
-	stordb := NewStorDBService(cfg, srvDep)
+	stordb := NewStorDBService(cfg, false, srvDep)
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
 	chrS := NewChargerService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep)
 	schS := NewSchedulerService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep)
@@ -214,7 +214,7 @@ func TestStorDBReloadVersion1(t *testing.T) {
 	shdChan := utils.NewSyncedChan()
 	cfg.ChargerSCfg().Enabled = true
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	stordb := NewStorDBService(cfg, srvDep)
+	stordb := NewStorDBService(cfg, false, srvDep)
 	stordb.oldDBCfg = cfg.StorDbCfg().Clone()
 	if err := engine.InitStorDb(cfg); err != nil {
 		t.Fatal(err)
@@ -297,7 +297,7 @@ func TestStorDBReloadVersion2(t *testing.T) {
 	cfg.ChargerSCfg().Enabled = true
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	cfg.StorDbCfg().Password = "CGRateS.org"
-	stordb := NewStorDBService(cfg, srvDep)
+	stordb := NewStorDBService(cfg, false, srvDep)
 	stordb.oldDBCfg = cfg.StorDbCfg().Clone()
 	if err := engine.InitStorDb(cfg); err != nil {
 		t.Fatal(err)
@@ -375,7 +375,7 @@ func TestStorDBReloadVersion3(t *testing.T) {
 	cfg.ChargerSCfg().Enabled = true
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	cfg.StorDbCfg().Password = "CGRateS.org"
-	stordb := NewStorDBService(cfg, srvDep)
+	stordb := NewStorDBService(cfg, false, srvDep)
 	stordb.oldDBCfg = cfg.StorDbCfg().Clone()
 	stordb.db = nil
 	err = stordb.Reload()
@@ -408,7 +408,7 @@ func TestStorDBReloadNewStorDBConnError(t *testing.T) {
 	cfg.ChargerSCfg().Enabled = true
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	cfg.StorDbCfg().Password = "CGRateS.org"
-	stordb := NewStorDBService(cfg, srvDep)
+	stordb := NewStorDBService(cfg, false, srvDep)
 	stordb.oldDBCfg = &config.StorDbCfg{
 		Type:     utils.MetaInternal,
 		Host:     "test_host",
@@ -435,7 +435,7 @@ func TestStorDBReloadStartDBError(t *testing.T) {
 	cfg.ChargerSCfg().Enabled = true
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	cfg.StorDbCfg().Password = "CGRateS.org"
-	stordb := NewStorDBService(cfg, srvDep)
+	stordb := NewStorDBService(cfg, false, srvDep)
 	cfg.StorDbCfg().Type = "badType"
 	err := stordb.Start()
 	expected := "unknown db 'badType' valid options are [*mysql, *mongo, *postgres, *internal]"

services/stordb_test.go

@@ -31,7 +31,7 @@ import (
 func TestStorDBServiceCoverage(t *testing.T) {
 	cfg := config.NewDefaultCGRConfig()
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
-	srv := NewStorDBService(cfg, srvDep)
+	srv := NewStorDBService(cfg, false, srvDep)
 	err := srv.IsRunning()
 	if err == true {
 		t.Errorf("Expected service to be down")

services/thresholds_it_test.go

@@ -54,7 +54,7 @@ func TestThresholdSReload(t *testing.T) {
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	tS := NewThresholdService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), anz, srvDep)
 	engine.NewConnManager(cfg, nil)
 	srvMngr.AddServices(tS,
@@ -123,7 +123,7 @@ func TestThresholdSReload2(t *testing.T) {
 	srvMngr := servmanager.NewServiceManager(cfg, shdChan, shdWg, nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	tS := NewThresholdService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), anz, srvDep)
 	engine.NewConnManager(cfg, nil)
 	srvMngr.AddServices(tS,

services/thresholds_test.go

@@ -39,7 +39,7 @@ func TestThresholdSCoverage(t *testing.T) {
 	server := cores.NewServer(nil)
 	srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)}
 	anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan birpc.ClientConnector, 1), srvDep)
-	db := NewDataDBService(cfg, nil, srvDep)
+	db := NewDataDBService(cfg, nil, false, srvDep)
 	tS := NewThresholdService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), anz, srvDep)
 	if tS.IsRunning() {
 		t.Errorf("Expected service to be down")