Updated migrator logs

cmd/cgr-migrator/cgr-migrator.go

@@ -31,7 +31,8 @@ import (
 )
 
 var (
-	sameDBname      = true
+	sameDataDB      = true
+	sameStorDB      = true
 	outDataDB       migrator.MigratorDataDB
 	storDB          engine.Storage
 	oDBDataEncoding string
@@ -76,7 +77,6 @@ var (
 	inDBDataEncoding = flag.String("in_dbData_encoding", "", "The encoding used to store object Data in strings")
 	dryRun           = flag.Bool("dry_run", false, "When true will not save loaded Data to DataDb but just parse it for consistency and errors.")
 	verbose          = flag.Bool("verbose", false, "Enable detailed verbose logging output")
-	stats            = flag.Bool("stats", false, "Generates statsistics about migrated Data.")
 )
 
 func main() {
@@ -85,10 +85,7 @@ func main() {
 		fmt.Println(utils.GetCGRVersion())
 		return
 	}
-	if *verbose {
-		log.Print("Initializing DataDB:", *inDataDBType)
-		log.Print("Initializing storDB:", *inStorDBType)
-	}
+
 	var dmIN *engine.DataManager
 	dmIN, _ = engine.ConfigureDataStorage(*inDataDBType, *inDataDBHost, *inDataDBPort,
 		*inDataDBName, *inDataDBUser, *inDataDBPass, *dbDataEncoding, config.CgrConfig().CacheCfg(), *loadHistorySize)
@@ -105,9 +102,6 @@ func main() {
 		*outDataDBUser = *inDataDBUser
 		*outDataDBPass = *inDataDBPass
 	}
-	if *verbose {
-		log.Print("Initializing outDataDB:", *outDataDBType)
-	}
 	var dmOUT *engine.DataManager
 	dmOUT, _ = engine.ConfigureDataStorage(*outDataDBType, *outDataDBHost, *outDataDBPort,
 		*outDataDBName, *outDataDBUser, *outDataDBPass, *dbDataEncoding, config.CgrConfig().CacheCfg(), *loadHistorySize)
@@ -117,13 +111,6 @@ func main() {
 	}
 	storDB = instorDB
 
-	if *verbose {
-		if *outStorDBType != "" {
-			log.Print("Initializing outStorDB:", *outStorDBType)
-		} else {
-			log.Print("Initializing outStorDB:", *inStorDBType)
-		}
-	}
 	if *outStorDBType != "" {
 		storDB, err = engine.ConfigureStorStorage(*outStorDBType, *outStorDBHost, *outStorDBPort, *outStorDBName, *outStorDBUser, *outStorDBPass, *dbDataEncoding,
 			config.CgrConfig().StorDBMaxOpenConns, config.CgrConfig().StorDBMaxIdleConns, config.CgrConfig().StorDBConnMaxLifetime, config.CgrConfig().StorDBCDRSIndexes)
@@ -131,48 +118,42 @@ func main() {
 			log.Fatal(err)
 		}
 	}
-	if *verbose {
-		log.Print("Migrating: ", *migrate)
+	if *inDataDBName != *outDataDBName || *inDataDBType != *outDataDBType || *inDataDBHost != *outDataDBHost {
+		sameDataDB = false
 	}
-	if inDataDBName != outDataDBName || inStorDBName != outStorDBName {
-		sameDBname = false
+	if *inStorDBName != *outStorDBName || *inStorDBType != *outStorDBName || *inStorDBHost != *outStorDBHost {
+		sameStorDB = false
 	}
 	m, err := migrator.NewMigrator(dmIN, dmOUT, *inDataDBType, *dbDataEncoding, storDB, *inStorDBType, outDataDB,
-		*outDataDBType, *inDBDataEncoding, instorDB, *outStorDBType, *dryRun, sameDBname, *datadb_versions, *stordb_versions)
+		*outDataDBType, *inDBDataEncoding, instorDB, *outStorDBType, *dryRun, sameDataDB, sameStorDB, *datadb_versions, *stordb_versions)
 	if err != nil {
 		log.Fatal(err)
 	}
 	if *datadb_versions {
 		vrs, _ := dmOUT.DataDB().GetVersions(utils.TBLVersions)
 		if len(vrs) != 0 {
-			log.Print("DataDB versions :", vrs)
+			log.Printf("DataDB versions : %+v\n", vrs)
 		} else {
-			log.Print("DataDB versions not_found")
+			log.Printf("DataDB versions not_found")
 		}
 	}
 	if *stordb_versions {
 		vrs, _ := storDB.GetVersions(utils.TBLVersions)
 		if len(vrs) != 0 {
-			log.Print("StorDB versions :", vrs)
+			log.Printf("StorDB versions : %+v\n", vrs)
 		} else {
-			log.Print("StorDB versions not_found")
+			log.Printf("StorDB versions not_found")
 		}
 	}
 	if migrate != nil && *migrate != "" { // Run migrator
 		migrstats := make(map[string]int)
 		mig := strings.Split(*migrate, ",")
-		log.Print("migrating", mig)
 		err, migrstats = m.Migrate(mig)
 		if err != nil {
 			log.Fatal(err)
 		}
-		if *stats != false {
-			for k, v := range migrstats {
-				log.Print(" ", k, " : ", v)
-			}
-		}
-		if *verbose {
-			log.Print("Done migrating!")
+		if *verbose != false {
+			log.Printf("Data migrated: %+v", migrstats)
 		}
 		return
 	}

migrator/accounts.go

@@ -51,6 +51,7 @@ func (m *Migrator) migrateCurrentAccounts() (err error) {
 				if err := m.dmOut.DataDB().SetAccount(acc); err != nil {
 					return err
 				}
+				m.stats[utils.Accounts] += 1
 			}
 		}
 	}
@@ -74,7 +75,6 @@ func (m *Migrator) migrateV1Accounts() (err error) {
 					return err
 				}
 				m.stats[utils.Accounts] += 1
-
 			}
 		}
 	}
@@ -108,7 +108,6 @@ func (m *Migrator) migrateV2Accounts() (err error) {
 					return err
 				}
 				m.stats[utils.Accounts] += 1
-
 			}
 		}
 	}
@@ -142,7 +141,7 @@ func (m *Migrator) migrateAccounts() (err error) {
 	}
 	switch vrs[utils.Accounts] {
 	case current[utils.Accounts]:
-		if m.sameDBname {
+		if m.sameDataDB {
 			return
 		}
 		if err := m.migrateCurrentAccounts(); err != nil {

migrator/action.go

@@ -56,6 +56,7 @@ func (m *Migrator) migrateCurrentActions() (err error) {
 				if err := m.dmOut.SetActions(idg, acts, utils.NonTransactional); err != nil {
 					return err
 				}
+				m.stats[utils.Actions] += 1
 			}
 		}
 	}
@@ -117,7 +118,7 @@ func (m *Migrator) migrateActions() (err error) {
 	}
 	switch vrs[utils.Actions] {
 	case current[utils.Actions]:
-		if m.sameDBname {
+		if m.sameDataDB {
 			return
 		}
 		if err := m.migrateCurrentActions(); err != nil {

migrator/action_plan.go

@@ -61,10 +61,10 @@ func (m *Migrator) migrateCurrentActionPlans() (err error) {
 		}
 		if acts != nil {
 			if m.dryRun != true {
-
 				if err := m.dmOut.DataDB().SetActionPlan(idg, acts, true, utils.NonTransactional); err != nil {
 					return err
 				}
+				m.stats[utils.ActionPlans] += 1
 			}
 		}
 	}
@@ -123,14 +123,13 @@ func (m *Migrator) migrateActionPlans() (err error) {
 	}
 	switch vrs[utils.ActionPlans] {
 	case current[utils.ActionPlans]:
-		if m.sameDBname {
+		if m.sameDataDB {
 			return
 		}
 		if err := m.migrateCurrentActionPlans(); err != nil {
 			return err
 		}
 		return
-
 	case 1:
 		if err := m.migrateV1ActionPlans(); err != nil {
 			return err

migrator/action_trigger.go

@@ -130,7 +130,7 @@ func (m *Migrator) migrateActionTriggers() (err error) {
 	}
 	switch vrs[utils.ActionTriggers] {
 	case current[utils.ActionTriggers]:
-		if m.sameDBname {
+		if m.sameDataDB {
 			return
 		}
 		if err := m.migrateCurrentActionTrigger(); err != nil {

migrator/alias.go

@@ -43,6 +43,7 @@ func (m *Migrator) migrateCurrentAlias() (err error) {
 				if err := m.dmOut.DataDB().SetAlias(usr, utils.NonTransactional); err != nil {
 					return err
 				}
+				m.stats[utils.Alias] += 1
 			}
 		}
 	}
@@ -68,8 +69,11 @@ func (m *Migrator) migrateCurrentReverseAlias() (err error) {
 				return err
 			}
 			if alias != nil {
-				if err := m.dmOut.DataDB().SetReverseAlias(alias, utils.NonTransactional); err != nil {
-					return err
+				if m.dryRun != true {
+					if err := m.dmOut.DataDB().SetReverseAlias(alias, utils.NonTransactional); err != nil {
+						return err
+					}
+					m.stats[utils.ReverseAlias] += 1
 				}
 			}
 		}
@@ -94,7 +98,7 @@ func (m *Migrator) migrateAlias() (err error) {
 	}
 	switch vrs[utils.Alias] {
 	case current[utils.Alias]:
-		if m.sameDBname {
+		if m.sameDataDB {
 			return
 		}
 		if err := m.migrateCurrentAlias(); err != nil {
@@ -122,7 +126,7 @@ func (m *Migrator) migrateReverseAlias() (err error) {
 	}
 	switch vrs[utils.ReverseAlias] {
 	case current[utils.ReverseAlias]:
-		if m.sameDBname {
+		if m.sameDataDB {
 			return
 		}
 		if err := m.migrateCurrentReverseAlias(); err != nil {

migrator/cdrstats.go

@@ -36,6 +36,7 @@ func (m *Migrator) migrateCurrentCdrStats() (err error) {
 				if err := m.dmOut.SetCdrStats(cdrst); err != nil {
 					return err
 				}
+				m.stats[utils.CdrStats] += 1
 			}
 		}
 	}
@@ -59,7 +60,7 @@ func (m *Migrator) migrateCdrStats() (err error) {
 	}
 	switch vrs[utils.CdrStats] {
 	case current[utils.CdrStats]:
-		if m.sameDBname {
+		if m.sameDataDB {
 			return
 		}
 		if err := m.migrateCurrentCdrStats(); err != nil {

migrator/derived_chargers.go

@@ -43,6 +43,7 @@ func (m *Migrator) migrateCurrentDerivedChargers() (err error) {
 				if err := m.dmOut.DataDB().SetDerivedChargers(id, drc, utils.NonTransactional); err != nil {
 					return err
 				}
+				m.stats[utils.DerivedChargersV] += 1
 			}
 		}
 	}
@@ -66,7 +67,7 @@ func (m *Migrator) migrateDerivedChargers() (err error) {
 	}
 	switch vrs[utils.DerivedChargersV] {
 	case current[utils.DerivedChargersV]:
-		if m.sameDBname {
+		if m.sameDataDB {
 			return
 		}
 		if err := m.migrateCurrentDerivedChargers(); err != nil {

migrator/destinations.go

@@ -43,6 +43,7 @@ func (m *Migrator) migrateCurrentDestinations() (err error) {
 				if err := m.dmOut.DataDB().SetDestination(dst, utils.NonTransactional); err != nil {
 					return err
 				}
+				m.stats[utils.Destinations] += 1
 			}
 		}
 	}
@@ -66,7 +67,7 @@ func (m *Migrator) migrateDestinations() (err error) {
 	}
 	switch vrs[utils.Destinations] {
 	case current[utils.Destinations]:
-		if m.sameDBname {
+		if m.sameDataDB {
 			return
 		}
 		if err := m.migrateCurrentDestinations(); err != nil {
@@ -94,8 +95,11 @@ func (m *Migrator) migrateCurrentReverseDestinations() (err error) {
 				return err
 			}
 			if rdst != nil {
-				if err := m.dmOut.DataDB().SetReverseDestination(rdst, utils.NonTransactional); err != nil {
-					return err
+				if m.dryRun != true {
+					if err := m.dmOut.DataDB().SetReverseDestination(rdst, utils.NonTransactional); err != nil {
+						return err
+					}
+					m.stats[utils.ReverseDestinations] += 1
 				}
 			}
 		}
@@ -120,7 +124,7 @@ func (m *Migrator) migrateReverseDestinations() (err error) {
 	}
 	switch vrs[utils.ReverseDestinations] {
 	case current[utils.ReverseDestinations]:
-		if m.sameDBname {
+		if m.sameDataDB {
 			return
 		}
 		if err := m.migrateCurrentReverseDestinations(); err != nil {

migrator/lcr.go

@@ -43,6 +43,7 @@ func (m *Migrator) migrateCurrentLCR() (err error) {
 				if err := m.dmOut.SetLCR(lcr, utils.NonTransactional); err != nil {
 					return err
 				}
+				m.stats[utils.LCR] += 1
 			}
 		}
 	}
@@ -66,7 +67,7 @@ func (m *Migrator) migrateLCR() (err error) {
 	}
 	switch vrs[utils.LCR] {
 	case current[utils.LCR]:
-		if m.sameDBname {
+		if m.sameDataDB {
 			return
 		}
 		if err := m.migrateCurrentLCR(); err != nil {

migrator/migrator.go

@@ -28,7 +28,7 @@ import (
 
 func NewMigrator(dmIN *engine.DataManager, dmOut *engine.DataManager, dataDBType, dataDBEncoding string,
 	storDB engine.Storage, storDBType string, oldDataDB MigratorDataDB, oldDataDBType, oldDataDBEncoding string,
-	oldStorDB engine.Storage, oldStorDBType string, dryRun bool, sameDBname bool, datadb_versions bool, stordb_versions bool) (m *Migrator, err error) {
+	oldStorDB engine.Storage, oldStorDBType string, dryRun bool, sameDataDB bool, sameStorDB bool, datadb_versions bool, stordb_versions bool) (m *Migrator, err error) {
 	var mrshlr engine.Marshaler
 	var oldmrshlr engine.Marshaler
 	if dataDBEncoding == utils.MSGPACK {
@@ -48,7 +48,8 @@ func NewMigrator(dmIN *engine.DataManager, dmOut *engine.DataManager, dataDBType
 		mrshlr: mrshlr, dmIN: dmIN,
 		oldDataDB: oldDataDB, oldDataDBType: oldDataDBType,
 		oldStorDB: oldStorDB, oldStorDBType: oldStorDBType,
-		oldmrshlr: oldmrshlr, dryRun: dryRun, sameDBname: sameDBname, datadb_versions: datadb_versions, stordb_versions: stordb_versions, stats: stats,
+		oldmrshlr: oldmrshlr, dryRun: dryRun, sameDataDB: sameDataDB, sameStorDB: sameStorDB,
+		datadb_versions: datadb_versions, stordb_versions: stordb_versions, stats: stats,
 	}
 	return m, err
 }
@@ -66,7 +67,8 @@ type Migrator struct {
 	oldStorDBType   string
 	oldmrshlr       engine.Marshaler
 	dryRun          bool
-	sameDBname      bool
+	sameDataDB      bool
+	sameStorDB      bool
 	datadb_versions bool
 	stordb_versions bool
 	stats           map[string]int
@@ -76,7 +78,6 @@ type Migrator struct {
 func (m *Migrator) Migrate(taskIDs []string) (err error, stats map[string]int) {
 	stats = make(map[string]int)
 	for _, taskID := range taskIDs {
-		log.Print("migrating", taskID)
 		switch taskID {
 		default: // unsupported taskID
 			err = utils.NewCGRError(utils.Migrator,

migrator/migrator_it_test.go

@@ -78,7 +78,7 @@ func TestMigratorITPostgresConnect(t *testing.T) {
 	if err != nil {
 		log.Fatal(err)
 	}
-	mig, err = NewMigrator(dataDB, dataDB2, postgresITCfg.DataDbType, postgresITCfg.DBDataEncoding, storDB, postgresITCfg.StorDBType, oldDataDB, postgresITCfg.DataDbType, postgresITCfg.DBDataEncoding, oldstorDB, postgresITCfg.StorDBType, false, true)
+	mig, err = NewMigrator(dataDB, dataDB2, postgresITCfg.DataDbType, postgresITCfg.DBDataEncoding, storDB, postgresITCfg.StorDBType, oldDataDB, postgresITCfg.DataDbType, postgresITCfg.DBDataEncoding, oldstorDB, postgresITCfg.StorDBType, false, true, true, false, false)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -120,7 +120,7 @@ func TestMigratorITRedisConnect(t *testing.T) {
 	if err != nil {
 		log.Fatal(err)
 	}
-	mig, err = NewMigrator(dataDB, dataDB2, mysqlITCfg.DataDbType, mysqlITCfg.DBDataEncoding, storDB, mysqlITCfg.StorDBType, oldDataDB, mysqlITCfg.DataDbType, mysqlITCfg.DBDataEncoding, oldstorDB, mysqlITCfg.StorDBType, false, true)
+	mig, err = NewMigrator(dataDB, dataDB2, mysqlITCfg.DataDbType, mysqlITCfg.DBDataEncoding, storDB, mysqlITCfg.StorDBType, oldDataDB, mysqlITCfg.DataDbType, mysqlITCfg.DBDataEncoding, oldstorDB, mysqlITCfg.StorDBType, false, true, true, false, false)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -162,7 +162,7 @@ func TestMigratorITMongoConnect(t *testing.T) {
 	if err != nil {
 		log.Fatal(err)
 	}
-	mig, err = NewMigrator(dataDB, dataDB2, mgoITCfg.DataDbType, mgoITCfg.DBDataEncoding, storDB, mgoITCfg.StorDBType, oldDataDB, mgoITCfg.DataDbType, mgoITCfg.DBDataEncoding, oldstorDB, mgoITCfg.StorDBType, false, true)
+	mig, err = NewMigrator(dataDB, dataDB2, mgoITCfg.DataDbType, mgoITCfg.DBDataEncoding, storDB, mgoITCfg.StorDBType, oldDataDB, mgoITCfg.DataDbType, mgoITCfg.DBDataEncoding, oldstorDB, mgoITCfg.StorDBType, false, true, true, false, false)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -209,7 +209,7 @@ func TestMigratorITMoveConnect(t *testing.T) {
 	if err != nil {
 		log.Fatal(err)
 	}
-	mig, err = NewMigrator(dataDB2, dataDB, mgoITCfg.DataDbType, mgoITCfg.DBDataEncoding, storDB, mgoITCfg.StorDBType, oldDataDB, mgoITCfg.DataDbType, mgoITCfg.DBDataEncoding, oldstorDB, mgoITCfg.StorDBType, false, false)
+	mig, err = NewMigrator(dataDB2, dataDB, mgoITCfg.DataDbType, mgoITCfg.DBDataEncoding, storDB, mgoITCfg.StorDBType, oldDataDB, mgoITCfg.DataDbType, mgoITCfg.DBDataEncoding, oldstorDB, mgoITCfg.StorDBType, false, false, false, false, false)
 	if err != nil {
 		log.Fatal(err)
 	}

migrator/rating_plan.go

@@ -43,6 +43,7 @@ func (m *Migrator) migrateCurrentRatingPlans() (err error) {
 				if err := m.dmOut.SetRatingPlan(rp, utils.NonTransactional); err != nil {
 					return err
 				}
+				m.stats[utils.RatingPlan] += 1
 			}
 		}
 	}
@@ -66,7 +67,7 @@ func (m *Migrator) migrateRatingPlans() (err error) {
 	}
 	switch vrs[utils.RatingPlan] {
 	case current[utils.RatingPlan]:
-		if m.sameDBname {
+		if m.sameDataDB {
 			return
 		}
 		if err := m.migrateCurrentRatingPlans(); err != nil {

migrator/rating_profile.go

@@ -43,6 +43,7 @@ func (m *Migrator) migrateCurrentRatingProfiles() (err error) {
 				if err := m.dmOut.SetRatingProfile(rp, utils.NonTransactional); err != nil {
 					return err
 				}
+				m.stats[utils.RatingProfile] += 1
 			}
 		}
 	}
@@ -66,7 +67,7 @@ func (m *Migrator) migrateRatingProfiles() (err error) {
 	}
 	switch vrs[utils.RatingProfile] {
 	case current[utils.RatingProfile]:
-		if m.sameDBname {
+		if m.sameDataDB {
 			return
 		}
 		if err := m.migrateCurrentRatingProfiles(); err != nil {

migrator/request_filter.go

@@ -43,6 +43,7 @@ func (m *Migrator) migrateCurrentRequestFilter() (err error) {
 				if err := m.dmOut.SetReqFilterIndexes(id, rq); err != nil {
 					return err
 				}
+				m.stats[utils.RQF] += 1
 			}
 		}
 	}
@@ -66,7 +67,7 @@ func (m *Migrator) migrateRequestFilter() (err error) {
 	}
 	switch vrs[utils.RQF] {
 	case current[utils.RQF]:
-		if m.sameDBname {
+		if m.sameDataDB {
 			return
 		}
 		if err := m.migrateCurrentRequestFilter(); err != nil {

migrator/resource.go

@@ -45,6 +45,7 @@ func (m *Migrator) migrateCurrentResource() (err error) {
 				if err := m.dmOut.SetResource(res); err != nil {
 					return err
 				}
+				m.stats[utils.Resource] += 1
 			}
 		}
 	}
@@ -68,7 +69,7 @@ func (m *Migrator) migrateResources() (err error) {
 	}
 	switch vrs[utils.Resource] {
 	case current[utils.Resource]:
-		if m.sameDBname {
+		if m.sameDataDB {
 			return
 		}
 		if err := m.migrateCurrentResource(); err != nil {

migrator/sharedgroup.go

@@ -103,7 +103,7 @@ func (m *Migrator) migrateSharedGroups() (err error) {
 	}
 	switch vrs[utils.SharedGroups] {
 	case current[utils.SharedGroups]:
-		if m.sameDBname {
+		if m.sameDataDB {
 			return
 		}
 		if err := m.migrateCurrentSharedGroups(); err != nil {

migrator/stats.go

@@ -78,6 +78,7 @@ func (m *Migrator) migrateCurrentStats() (err error) {
 				if err := m.dmOut.SetStatQueue(sgs); err != nil {
 					return err
 				}
+				m.stats[utils.StatS] += 1
 			}
 		}
 	}
@@ -171,7 +172,7 @@ func (m *Migrator) migrateStats() (err error) {
 	}
 	switch vrs[utils.StatS] {
 	case current[utils.StatS]:
-		if m.sameDBname {
+		if m.sameDataDB {
 			return
 		}
 		if err := m.migrateCurrentStats(); err != nil {

migrator/subscribers.go

@@ -36,6 +36,7 @@ func (m *Migrator) migrateCurrentSubscribers() (err error) {
 				if err := m.dmOut.SetSubscriber(id, sub); err != nil {
 					return err
 				}
+				m.stats[utils.Subscribers] += 1
 			}
 		}
 	}
@@ -59,7 +60,7 @@ func (m *Migrator) migrateSubscribers() (err error) {
 	}
 	switch vrs[utils.Subscribers] {
 	case current[utils.Subscribers]:
-		if m.sameDBname {
+		if m.sameDataDB {
 			return
 		}
 		if err := m.migrateCurrentSubscribers(); err != nil {

migrator/thresholds.go

@@ -66,6 +66,7 @@ func (m *Migrator) migrateCurrentThresholds() (err error) {
 				if err := m.dmOut.SetThreshold(ths); err != nil {
 					return err
 				}
+				m.stats[utils.Thresholds] += 1
 			}
 		}
 	}
@@ -150,7 +151,7 @@ func (m *Migrator) migrateThresholds() (err error) {
 	}
 	switch vrs[utils.Thresholds] {
 	case current[utils.Thresholds]:
-		if m.sameDBname {
+		if m.sameDataDB {
 			return
 		}
 		if err := m.migrateCurrentThresholds(); err != nil {

migrator/timings.go

@@ -43,6 +43,7 @@ func (m *Migrator) migrateCurrentTiming() (err error) {
 				if err := m.dmOut.SetTiming(tm); err != nil {
 					return err
 				}
+				m.stats[utils.Timing] += 1
 			}
 		}
 	}
@@ -66,7 +67,7 @@ func (m *Migrator) migrateTimings() (err error) {
 	}
 	switch vrs[utils.Timing] {
 	case current[utils.Timing]:
-		if m.sameDBname {
+		if m.sameDataDB {
 			return
 		}
 		if err := m.migrateCurrentTiming(); err != nil {

migrator/tp_account_actions.go

@@ -30,7 +30,6 @@ func (m *Migrator) migrateCurrentTPaccountacction() (err error) {
 	if err != nil {
 		return err
 	}
-
 	for _, tpid := range tpids {
 		dest, err := m.InStorDB().GetTPAccountActions(&utils.TPAccountActions{TPid: tpid})
 		if err != nil {
@@ -41,6 +40,7 @@ func (m *Migrator) migrateCurrentTPaccountacction() (err error) {
 				if err := m.OutStorDB().SetTPAccountActions(dest); err != nil {
 					return err
 				}
+				m.stats[utils.TpAccountActions] += 1
 			}
 		}
 	}
@@ -64,7 +64,7 @@ func (m *Migrator) migrateTPaccountacction() (err error) {
 	}
 	switch vrs[utils.TpAccountActions] {
 	case current[utils.TpAccountActions]:
-		if m.sameDBname {
+		if m.sameStorDB {
 			return
 		}
 		if err := m.migrateCurrentTPaccountacction(); err != nil {

migrator/tp_action_plans.go

@@ -30,14 +30,12 @@ func (m *Migrator) migrateCurrentTPactionplans() (err error) {
 	if err != nil {
 		return err
 	}
-
 	for _, tpid := range tpids {
 		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPActionPlans, utils.TPDistinctIds{}, map[string]string{}, nil)
 		if err != nil {
 			return err
 		}
 		for _, id := range ids {
-
 			dest, err := m.InStorDB().GetTPActionPlans(tpid, id)
 			if err != nil {
 				return err
@@ -47,6 +45,7 @@ func (m *Migrator) migrateCurrentTPactionplans() (err error) {
 					if err := m.OutStorDB().SetTPActionPlans(dest); err != nil {
 						return err
 					}
+					m.stats[utils.TpActionPlans] += 1
 				}
 			}
 		}
@@ -71,7 +70,7 @@ func (m *Migrator) migrateTPactionplans() (err error) {
 	}
 	switch vrs[utils.TpActionPlans] {
 	case current[utils.TpActionPlans]:
-		if m.sameDBname {
+		if m.sameStorDB {
 			return
 		}
 		if err := m.migrateCurrentTPactionplans(); err != nil {

migrator/tp_action_triggers.go

@@ -30,14 +30,12 @@ func (m *Migrator) migrateCurrentTPactiontriggers() (err error) {
 	if err != nil {
 		return err
 	}
-
 	for _, tpid := range tpids {
 		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPActionTriggers, utils.TPDistinctIds{}, map[string]string{}, nil)
 		if err != nil {
 			return err
 		}
 		for _, id := range ids {
-
 			dest, err := m.InStorDB().GetTPActionTriggers(tpid, id)
 			if err != nil {
 				return err
@@ -47,6 +45,7 @@ func (m *Migrator) migrateCurrentTPactiontriggers() (err error) {
 					if err := m.OutStorDB().SetTPActionTriggers(dest); err != nil {
 						return err
 					}
+					m.stats[utils.TpActionTriggers] += 1
 				}
 			}
 		}
@@ -71,7 +70,7 @@ func (m *Migrator) migrateTPactiontriggers() (err error) {
 	}
 	switch vrs[utils.TpActionTriggers] {
 	case current[utils.TpActionTriggers]:
-		if m.sameDBname {
+		if m.sameStorDB {
 			return
 		}
 		if err := m.migrateCurrentTPactiontriggers(); err != nil {

migrator/tp_actions.go

@@ -30,14 +30,12 @@ func (m *Migrator) migrateCurrentTPactions() (err error) {
 	if err != nil {
 		return err
 	}
-
 	for _, tpid := range tpids {
 		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPActions, utils.TPDistinctIds{}, map[string]string{}, nil)
 		if err != nil {
 			return err
 		}
 		for _, id := range ids {
-
 			dest, err := m.InStorDB().GetTPActions(tpid, id)
 			if err != nil {
 				return err
@@ -47,6 +45,7 @@ func (m *Migrator) migrateCurrentTPactions() (err error) {
 					if err := m.OutStorDB().SetTPActions(dest); err != nil {
 						return err
 					}
+					m.stats[utils.TpActions] += 1
 				}
 			}
 		}
@@ -71,7 +70,7 @@ func (m *Migrator) migrateTPactions() (err error) {
 	}
 	switch vrs[utils.TpActions] {
 	case current[utils.TpActions]:
-		if m.sameDBname {
+		if m.sameStorDB {
 			return
 		}
 		if err := m.migrateCurrentTPactions(); err != nil {

migrator/tp_aliases.go

@@ -30,7 +30,6 @@ func (m *Migrator) migrateCurrentTPaliases() (err error) {
 	if err != nil {
 		return err
 	}
-
 	for _, tpid := range tpids {
 		dest, err := m.InStorDB().GetTPAliases(&utils.TPAliases{TPid: tpid})
 		if err != nil {
@@ -41,6 +40,7 @@ func (m *Migrator) migrateCurrentTPaliases() (err error) {
 				if err := m.OutStorDB().SetTPAliases(dest); err != nil {
 					return err
 				}
+				m.stats[utils.TpAliases] += 1
 			}
 		}
 	}
@@ -65,7 +65,7 @@ func (m *Migrator) migrateTPaliases() (err error) {
 	}
 	switch vrs[utils.TpAliases] {
 	case current[utils.TpAliases]:
-		if m.sameDBname {
+		if m.sameStorDB {
 			return
 		}
 		if err := m.migrateCurrentTPaliases(); err != nil {

migrator/tp_cdr_stats.go

@@ -30,14 +30,12 @@ func (m *Migrator) migrateCurrentTPcdrstats() (err error) {
 	if err != nil {
 		return err
 	}
-
 	for _, tpid := range tpids {
 		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPCdrStats, utils.TPDistinctIds{}, map[string]string{}, nil)
 		if err != nil {
 			return err
 		}
 		for _, id := range ids {
-
 			dest, err := m.InStorDB().GetTPCdrStats(tpid, id)
 			if err != nil {
 				return err
@@ -47,6 +45,7 @@ func (m *Migrator) migrateCurrentTPcdrstats() (err error) {
 					if err := m.OutStorDB().SetTPCdrStats(dest); err != nil {
 						return err
 					}
+					m.stats[utils.TpCdrStats] += 1
 				}
 			}
 		}
@@ -71,7 +70,7 @@ func (m *Migrator) migrateTPcdrstats() (err error) {
 	}
 	switch vrs[utils.TpCdrStats] {
 	case current[utils.TpCdrStats]:
-		if m.sameDBname {
+		if m.sameStorDB {
 			return
 		}
 		if err := m.migrateCurrentTPcdrstats(); err != nil {

migrator/tp_derived_chargers.go

@@ -39,10 +39,10 @@ func (m *Migrator) migrateCurrentTPderivedchargers() (err error) {
 		}
 		if dest != nil {
 			if m.dryRun != true {
-
 				if err := m.OutStorDB().SetTPDerivedChargers(dest); err != nil {
 					return err
 				}
+				m.stats[utils.TpDerivedCharges] += 1
 			}
 		}
 	}
@@ -66,7 +66,7 @@ func (m *Migrator) migrateTPderivedchargers() (err error) {
 	}
 	switch vrs[utils.TpDerivedCharges] {
 	case current[utils.TpDerivedCharges]:
-		if m.sameDBname {
+		if m.sameStorDB {
 			return
 		}
 		if err := m.migrateCurrentTPderivedchargers(); err != nil {

migrator/tp_destination_rates.go

@@ -46,6 +46,7 @@ func (m *Migrator) migrateCurrentTPdestinationrates() (err error) {
 					if err := m.OutStorDB().SetTPDestinationRates(dest); err != nil {
 						return err
 					}
+					m.stats[utils.TpDestinationRates] += 1
 				}
 			}
 		}
@@ -70,7 +71,7 @@ func (m *Migrator) migrateTPdestinationrates() (err error) {
 	}
 	switch vrs[utils.TpDestinationRates] {
 	case current[utils.TpDestinationRates]:
-		if m.sameDBname {
+		if m.sameStorDB {
 			return
 		}
 		if err := m.migrateCurrentTPdestinationrates(); err != nil {

migrator/tp_destinations.go

@@ -46,6 +46,7 @@ func (m *Migrator) migrateCurrentTPDestinations() (err error) {
 					if err := m.OutStorDB().SetTPDestinations(dest); err != nil {
 						return err
 					}
+					m.stats[utils.TpDestinations] += 1
 				}
 			}
 		}
@@ -70,7 +71,7 @@ func (m *Migrator) migrateTPDestinations() (err error) {
 	}
 	switch vrs[utils.TpDestinations] {
 	case current[utils.TpDestinations]:
-		if m.sameDBname {
+		if m.sameStorDB {
 			return
 		}
 		if err := m.migrateCurrentTPDestinations(); err != nil {

migrator/tp_filters.go

@@ -46,6 +46,7 @@ func (m *Migrator) migrateCurrentTPfilters() (err error) {
 					if err := m.OutStorDB().SetTPFilters(dest); err != nil {
 						return err
 					}
+					m.stats[utils.TpFilters] += 1
 				}
 			}
 		}
@@ -70,7 +71,7 @@ func (m *Migrator) migrateTPfilters() (err error) {
 	}
 	switch vrs[utils.TpFilters] {
 	case current[utils.TpFilters]:
-		if m.sameDBname {
+		if m.sameStorDB {
 			return
 		}
 		if err := m.migrateCurrentTPfilters(); err != nil {

migrator/tp_lcrs.go

@@ -41,6 +41,7 @@ func (m *Migrator) migrateCurrentTPlcrs() (err error) {
 				if err := m.OutStorDB().SetTPLCRs(dest); err != nil {
 					return err
 				}
+				m.stats[utils.TpLcrs] += 1
 			}
 		}
 	}
@@ -64,7 +65,7 @@ func (m *Migrator) migrateTPlcrs() (err error) {
 	}
 	switch vrs[utils.TpLcrs] {
 	case current[utils.TpLcrs]:
-		if m.sameDBname {
+		if m.sameStorDB {
 			return
 		}
 		if err := m.migrateCurrentTPcdrstats(); err != nil {

migrator/tp_rates.go

@@ -47,6 +47,7 @@ func (m *Migrator) migrateCurrentTPrates() (err error) {
 					if err := m.OutStorDB().SetTPRates(dest); err != nil {
 						return err
 					}
+					m.stats[utils.TpRates] += 1
 				}
 			}
 		}
@@ -71,7 +72,7 @@ func (m *Migrator) migrateTPrates() (err error) {
 	}
 	switch vrs[utils.TpRates] {
 	case current[utils.TpRates]:
-		if m.sameDBname {
+		if m.sameStorDB {
 			return
 		}
 		if err := m.migrateCurrentTPrates(); err != nil {

migrator/tp_rating_plans.go

@@ -47,6 +47,7 @@ func (m *Migrator) migrateCurrentTPratingplans() (err error) {
 					if err := m.InStorDB().SetTPRatingPlans(rps); err != nil {
 						return err
 					}
+					m.stats[utils.TpRatingPlans] += 1
 				}
 			}
 		}
@@ -71,7 +72,7 @@ func (m *Migrator) migrateTPratingplans() (err error) {
 	}
 	switch vrs[utils.TpRatingPlans] {
 	case current[utils.TpRatingPlans]:
-		if m.sameDBname {
+		if m.sameStorDB {
 			return
 		}
 		if err := m.migrateCurrentTPratingplans(); err != nil {

migrator/tp_rating_profiles.go

@@ -42,6 +42,7 @@ func (m *Migrator) migrateCurrentTPratingprofiles() (err error) {
 				if err := m.OutStorDB().SetTPRatingProfiles(dest); err != nil {
 					return err
 				}
+				m.stats[utils.TpRatingProfiles] += 1
 			}
 		}
 	}
@@ -65,7 +66,7 @@ func (m *Migrator) migrateTPratingprofiles() (err error) {
 	}
 	switch vrs[utils.TpRatingProfiles] {
 	case current[utils.TpRatingProfiles]:
-		if m.sameDBname {
+		if m.sameStorDB {
 			return
 		}
 		if err := m.migrateCurrentTPratingprofiles(); err != nil {

migrator/tp_resources.go

@@ -47,6 +47,7 @@ func (m *Migrator) migrateCurrentTPresources() (err error) {
 					if err := m.OutStorDB().SetTPResources(dest); err != nil {
 						return err
 					}
+					m.stats[utils.TpResources] += 1
 				}
 			}
 		}
@@ -71,7 +72,7 @@ func (m *Migrator) migrateTPresources() (err error) {
 	}
 	switch vrs[utils.TpResources] {
 	case current[utils.TpResources]:
-		if m.sameDBname {
+		if m.sameStorDB {
 			return
 		}
 		if err := m.migrateCurrentTPresources(); err != nil {

migrator/tp_shared_groups.go

@@ -47,6 +47,7 @@ func (m *Migrator) migrateCurrentTPsharedgroups() (err error) {
 					if err := m.OutStorDB().SetTPSharedGroups(dest); err != nil {
 						return err
 					}
+					m.stats[utils.TpSharedGroups] += 1
 				}
 			}
 		}
@@ -71,7 +72,7 @@ func (m *Migrator) migrateTPsharedgroups() (err error) {
 	}
 	switch vrs[utils.TpSharedGroups] {
 	case current[utils.TpSharedGroups]:
-		if m.sameDBname {
+		if m.sameStorDB {
 			return
 		}
 		if err := m.migrateCurrentTPsharedgroups(); err != nil {

migrator/tp_stats.go

@@ -47,6 +47,7 @@ func (m *Migrator) migrateCurrentTPstats() (err error) {
 					if err := m.OutStorDB().SetTPStats(dest); err != nil {
 						return err
 					}
+					m.stats[utils.TpStats] += 1
 				}
 			}
 		}
@@ -71,7 +72,7 @@ func (m *Migrator) migrateTPstats() (err error) {
 	}
 	switch vrs[utils.TpStats] {
 	case current[utils.TpStats]:
-		if m.sameDBname {
+		if m.sameStorDB {
 			return
 		}
 		if err := m.migrateCurrentTPstats(); err != nil {

migrator/tp_thresholds.go

@@ -47,6 +47,7 @@ func (m *Migrator) migrateCurrentTPthresholds() (err error) {
 					if err := m.OutStorDB().SetTPThresholds(dest); err != nil {
 						return err
 					}
+					m.stats[utils.TpThresholds] += 1
 				}
 			}
 		}
@@ -71,7 +72,7 @@ func (m *Migrator) migrateTPthresholds() (err error) {
 	}
 	switch vrs[utils.TpThresholds] {
 	case current[utils.TpThresholds]:
-		if m.sameDBname {
+		if m.sameStorDB {
 			return
 		}
 		if err := m.migrateCurrentTPthresholds(); err != nil {

migrator/tp_timings.go

@@ -47,6 +47,7 @@ func (m *Migrator) migrateCurrentTPTiming() (err error) {
 					if err := m.OutStorDB().SetTPTimings(tm); err != nil {
 						return err
 					}
+					m.stats[utils.TpTiming] += 1
 				}
 			}
 		}
@@ -71,7 +72,7 @@ func (m *Migrator) migrateTpTimings() (err error) {
 	}
 	switch vrs[utils.TpTiming] {
 	case current[utils.TpTiming]:
-		if m.sameDBname {
+		if m.sameStorDB {
 			return
 		}
 		if err := m.migrateCurrentTPTiming(); err != nil {

migrator/tp_users.go

@@ -41,6 +41,7 @@ func (m *Migrator) migrateCurrentTPusers() (err error) {
 				if err := m.OutStorDB().SetTPUsers(dest); err != nil {
 					return err
 				}
+				m.stats[utils.TpUsers] += 1
 			}
 		}
 
@@ -65,7 +66,7 @@ func (m *Migrator) migrateTPusers() (err error) {
 	}
 	switch vrs[utils.TpUsers] {
 	case current[utils.TpUsers]:
-		if m.sameDBname {
+		if m.sameStorDB {
 			return
 		}
 		if err := m.migrateCurrentTPusers(); err != nil {

migrator/user.go

@@ -43,6 +43,7 @@ func (m *Migrator) migrateCurrentUser() (err error) {
 				if err := m.dmOut.SetUser(usr); err != nil {
 					return err
 				}
+				m.stats[utils.User] += 1
 			}
 		}
 	}
@@ -66,7 +67,7 @@ func (m *Migrator) migrateUser() (err error) {
 	}
 	switch vrs[utils.User] {
 	case current[utils.User]:
-		if m.sameDBname {
+		if m.sameStorDB {
 			return
 		}
 		if err := m.migrateCurrentUser(); err != nil {