Change infrastructure from migrator

migrator/migrator.go

@@ -26,13 +26,14 @@ import (
 	"github.com/cgrates/cgrates/utils"
 )
 
-func NewMigrator(dmIN *engine.DataManager, dmOut *engine.DataManager,
-	dataDBType, dataDBEncoding string,
-	storDBIn engine.StorDB, storDBOut engine.StorDB, storDBType string,
-	oldDataDB MigratorDataDB, oldDataDBType, oldDataDBEncoding string,
-	oldStorDB MigratorStorDB, oldStorDBType string,
-	dryRun bool, sameDataDB bool, sameStorDB bool,
-	datadb_versions bool, stordb_versions bool) (m *Migrator, err error) {
+func NewMigrator(
+	dmIN MigratorDataDB,
+	dmOut MigratorDataDB,
+	storDBIn MigratorStorDB,
+	storDBOut MigratorStorDB,
+	dryRun bool,
+	sameDataDB bool,
+	sameStorDB bool) (m *Migrator, err error) {
 	var mrshlr engine.Marshaler
 	var oldmrshlr engine.Marshaler
 	if dataDBEncoding == utils.MSGPACK {
@@ -47,36 +48,26 @@ func NewMigrator(dmIN *engine.DataManager, dmOut *engine.DataManager,
 	stats := make(map[string]int)
 
 	m = &Migrator{
-		dmOut: dmOut, dmIN: dmIN, dataDBType: dataDBType,
-		storDBIn: storDBIn, storDBOut: storDBOut, storDBType: storDBType,
-		mrshlr:    mrshlr,
-		oldDataDB: oldDataDB, oldDataDBType: oldDataDBType,
-		oldStorDB: oldStorDB, oldStorDBType: oldStorDBType,
-		oldmrshlr: oldmrshlr, dryRun: dryRun, sameDataDB: sameDataDB, sameStorDB: sameStorDB,
-		datadb_versions: datadb_versions, stordb_versions: stordb_versions, stats: stats,
+		dmOut:      dmOut,
+		dmIN:       dmIN,
+		storDBIn:   storDBIn,
+		storDBOut:  storDBOut,
+		storDBType: storDBType,
+		dryRun:     dryRun, sameDataDB: sameDataDB, sameStorDB: sameStorDB,
+		stats: stats,
 	}
 	return m, err
 }
 
 type Migrator struct {
-	dmIN            *engine.DataManager //oldatadb
-	dmOut           *engine.DataManager
-	dataDBType      string
-	storDBIn        engine.StorDB //oldStorDB
-	storDBOut       engine.StorDB
-	storDBType      string
-	mrshlr          engine.Marshaler
-	oldDataDB       MigratorDataDB
-	oldDataDBType   string
-	oldStorDB       MigratorStorDB
-	oldStorDBType   string
-	oldmrshlr       engine.Marshaler
-	dryRun          bool
-	sameDataDB      bool
-	sameStorDB      bool
-	datadb_versions bool
-	stordb_versions bool
-	stats           map[string]int
+	dmIN       MigratorDataDB
+	dmOut      MigratorDataDB
+	storDBIn   MigratorStorDB
+	storDBOut  MigratorStorDB
+	dryRun     bool
+	sameDataDB bool
+	sameStorDB bool
+	stats      map[string]int
 }
 
 // Migrate implements the tasks to migrate, used as a dispatcher to the individual methods
@@ -91,34 +82,18 @@ func (m *Migrator) Migrate(taskIDs []string) (err error, stats map[string]int) {
 				fmt.Sprintf("task <%s> is not a supported migration task", taskID))
 		case utils.MetaSetVersions:
 			if m.dryRun != true {
-
 				if err := m.dmOut.DataDB().SetVersions(engine.CurrentDBVersions(m.dataDBType), true); err != nil {
 					return utils.NewCGRError(utils.Migrator,
 						utils.ServerErrorCaps,
 						err.Error(),
 						fmt.Sprintf("error: <%s> when updating CostDetails version into StorDB", err.Error())), nil
 				}
-				if m.datadb_versions {
-					vrs, err := m.dmOut.DataDB().GetVersions("")
-					if err != nil {
-						return err, nil
-					}
-					log.Print("After migrate, DataDB versions :", vrs)
-				}
-
 				if err := m.storDBOut.SetVersions(engine.CurrentDBVersions(m.storDBType), true); err != nil {
 					return utils.NewCGRError(utils.Migrator,
 						utils.ServerErrorCaps,
 						err.Error(),
 						fmt.Sprintf("error: <%s> when updating CostDetails version into StorDB", err.Error())), nil
 				}
-				if m.stordb_versions {
-					vrs, err := m.storDBOut.GetVersions("")
-					if err != nil {
-						return err, nil
-					}
-					log.Print("After migrate, StorDB versions :", vrs)
-				}
 
 			} else {
 				log.Print("Cannot dryRun SetVersions!")

migrator/migratorDataDB.go

@@ -38,4 +38,5 @@ type MigratorDataDB interface {
 	setV2Account(x *v2Account) (err error)
 	getV1AttributeProfile() (v1attrPrf *v1AttributeProfile, err error)
 	setV1AttributeProfile(x *v1AttributeProfile) (err error)
+	DataManager() *engine.DataManager
 }

migrator/migratorStorDB.go

@@ -21,7 +21,8 @@ package migrator
 type MigratorStorDB interface {
 	getV1CDR() (v1Cdr *v1Cdrs, err error)
 	setV1CDR(v1Cdr *v1Cdrs) (err error)
-	getSMCost() (v2Cost *v2SessionsCost, err error)
-	setSMCost(v2Cost *v2SessionsCost) (err error)
-	remSMCost(v2Cost *v2SessionsCost) (err error)
+	getV2SMCost() (v2Cost *v2SessionsCost, err error)
+	setV2SMCost(v2Cost *v2SessionsCost) (err error)
+	remV2SMCost(v2Cost *v2SessionsCost) (err error)
+	StorDB() engine.StorDB
 }

migrator/v1migrator_utils.go

@@ -26,8 +26,13 @@ import (
 	"github.com/cgrates/cgrates/utils"
 )
 
-func ConfigureV1DataStorage(db_type, host, port, name, user, pass, marshaler string) (db MigratorDataDB, err error) {
+func NewMigratorDataDB(db_type, host, port, name, user, pass, marshaler string) {
+
+}
+
+func ConfigureV1DataStorage() (db MigratorDataDB, err error) {
 	var d MigratorDataDB
+	d.DataManger().(engine.RedisStoarage)
 	switch db_type {
 	case utils.REDIS:
 		var db_nb int

migrator/v1mongo_data.go

@@ -33,10 +33,9 @@ const (
 	v1AttributeProfilesCol = "attribute_profiles"
 )
 
-type v1Mongo struct {
-	session *mgo.Session
-	db      string
-	v1ms    engine.Marshaler
+type mongoMigrator struct {
+	dm      *engine.DataManager
+	mgoDB   *engine.MongoStorage
 	qryIter *mgo.Iter
 }
 
@@ -49,6 +48,10 @@ type AtKeyValue struct {
 	Value v1ActionPlans
 }
 
+func newmongoMigrator(dm *engine.DataManager) {
+
+}
+
 func newv1MongoStorage(host, port, db, user, pass, storageType string, cdrsIndexes []string) (v1ms *v1Mongo, err error) {
 	url := host
 	if port != "" {

migrator/v1redis.go

@@ -29,14 +29,18 @@ import (
 	"github.com/mediocregopher/radix.v2/redis"
 )
 
-type v1Redis struct {
-	dbPool   *pool.Pool
-	ms       engine.Marshaler
+type redisMigrator struct {
+	dm       *engine.DataManager
+	rds *engine.RedisStorage 
 	dataKeys []string
 	qryIdx   *int
 }
 
-func newv1RedisStorage(address string, db int, pass, mrshlerStr string) (*v1Redis, error) {
+func newredisMigrator(dm *engine.Datamnager) ( rM *redisMigrator, error) {
+	rM.rds = dm.DataDB().(*engine.RedisStorage)
+
+
+
 	df := func(network, addr string) (*redis.Client, error) {
 		client, err := redis.Dial(network, addr)
 		if err != nil {

migrator/v1sql.go

@@ -29,9 +29,9 @@ import (
 	"github.com/jinzhu/gorm"
 )
 
-type sqlStorage struct {
-	Db      *sql.DB
-	db      *gorm.DB
+type migratorSQL struct {
+	storDB  *engine.StorDB
+	sqlDB   *sql.DB
 	rowIter *sql.Rows
 }