uppal/cgrates
1
0
Fork 1
mirror of https://github.com/cgrates/cgrates.git synced 2026-02-11 18:16:24 +05:00
Code Issues Packages Projects Releases Wiki Activity

Updated migrator tests

Browse Source
This commit is contained in:
Trial97
2019-03-07 15:25:48 +02:00
committed by Dan Christian Bogos
parent 21482f2d92
commit c4487efc79
28 changed files with 589 additions and 3027 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
migrator/accounts.go
View File

@@ -46,17 +46,16 @@ func (m *Migrator) migrateCurrentAccounts() (err error) {
if err != nil {
return err
}
if acc != nil {
if m.dryRun != true {
if err := m.dmOut.DataManager().DataDB().SetAccount(acc); err != nil {
return err
}
if err := m.dmIN.DataManager().DataDB().RemoveAccount(idg); err != nil {
return err
}
m.stats[utils.Accounts] += 1
}
if acc == nil || m.dryRun {
continue
}
if err := m.dmOut.DataManager().DataDB().SetAccount(acc); err != nil {
return err
}
if err := m.dmIN.DataManager().DataDB().RemoveAccount(idg); err != nil {
return err
}
m.stats[utils.Accounts] += 1
}
return
}
@@ -71,28 +70,28 @@ func (m *Migrator) migrateV1Accounts() (err error) {
if err == utils.ErrNoMoreData {
break
}
if v1Acnt != nil {
acnt := v1Acnt.V1toV3Account()
if m.dryRun != true {
if err = m.dmOut.DataManager().DataDB().SetAccount(acnt); err != nil {
return err
}
if err = m.dmIN.remV1Account(v1Acnt.Id); err != nil {
return err
}
m.stats[utils.Accounts] += 1
}
if v1Acnt == nil || m.dryRun {
continue
}
acnt := v1Acnt.V1toV3Account()
if err = m.dmOut.DataManager().DataDB().SetAccount(acnt); err != nil {
return err
}
if err = m.dmIN.remV1Account(v1Acnt.Id); err != nil {
return err
}
m.stats[utils.Accounts] += 1
}
if m.dryRun != true {
// All done, update version wtih current one
vrs := engine.Versions{utils.Accounts: engine.CurrentDataDBVersions()[utils.Accounts]}
if err = m.dmOut.DataManager().DataDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating Accounts version into StorDB", err.Error()))
}
if m.dryRun {
return
}
// All done, update version wtih current one
vrs := engine.Versions{utils.Accounts: engine.CurrentDataDBVersions()[utils.Accounts]}
if err = m.dmOut.DataManager().DataDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating Accounts version into StorDB", err.Error()))
}
return
}
@@ -107,28 +106,28 @@ func (m *Migrator) migrateV2Accounts() (err error) {
if err == utils.ErrNoMoreData {
break
}
if v2Acnt != nil {
acnt := v2Acnt.V2toV3Account()
if m.dryRun != true {
if err = m.dmOut.DataManager().DataDB().SetAccount(acnt); err != nil {
return err
}
if err = m.dmIN.remV2Account(v2Acnt.ID); err != nil {
return err
}
m.stats[utils.Accounts] += 1
}
if v2Acnt == nil || m.dryRun {
continue
}
acnt := v2Acnt.V2toV3Account()
if err = m.dmOut.DataManager().DataDB().SetAccount(acnt); err != nil {
return err
}
if err = m.dmIN.remV2Account(v2Acnt.ID); err != nil {
return err
}
m.stats[utils.Accounts] += 1
}
if m.dryRun != true {
// All done, update version wtih current one
vrs := engine.Versions{utils.Accounts: engine.CurrentDataDBVersions()[utils.Accounts]}
if err = m.dmOut.DataManager().DataDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating Accounts version into StorDB", err.Error()))
}
if m.dryRun {
return
}
// All done, update version wtih current one
vrs := engine.Versions{utils.Accounts: engine.CurrentDataDBVersions()[utils.Accounts]}
if err = m.dmOut.DataManager().DataDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating Accounts version into StorDB", err.Error()))
}
return
}
@@ -149,7 +148,6 @@ func (m *Migrator) migrateAccounts() (err error) {
}
current := engine.CurrentDataDBVersions()
switch vrs[utils.Accounts] {
case 1:
return m.migrateV1Accounts()
case 2:

63
migrator/action.go
View File

@@ -51,14 +51,13 @@ func (m *Migrator) migrateCurrentActions() (err error) {
if err != nil {
return err
}
if acts != nil {
if m.dryRun != true {
if err := m.dmOut.DataManager().SetActions(idg, acts, utils.NonTransactional); err != nil {
return err
}
m.stats[utils.Actions] += 1
}
if acts == nil || m.dryRun {
continue
}
if err := m.dmOut.DataManager().SetActions(idg, acts, utils.NonTransactional); err != nil {
return err
}
m.stats[utils.Actions] += 1
}
return
}
@@ -74,29 +73,29 @@ func (m *Migrator) migrateV1Actions() (err error) {
if err == utils.ErrNoMoreData {
break
}
if *v1ACs != nil {
for _, v1ac := range *v1ACs {
act := v1ac.AsAction()
acts = append(acts, act)
if *v1ACs == nil || m.dryRun {
continue
}
for _, v1ac := range *v1ACs {
act := v1ac.AsAction()
acts = append(acts, act)
}
if !m.dryRun {
if err := m.dmOut.DataManager().SetActions(acts[0].Id, acts, utils.NonTransactional); err != nil {
return err
}
m.stats[utils.Actions] += 1
}
}
if err := m.dmOut.DataManager().SetActions(acts[0].Id, acts, utils.NonTransactional); err != nil {
return err
}
m.stats[utils.Actions] += 1
}
if !m.dryRun {
// All done, update version wtih current one
vrs := engine.Versions{utils.Actions: engine.CurrentStorDBVersions()[utils.Actions]}
if err = m.dmOut.DataManager().DataDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating Actions version into dataDB", err.Error()))
}
if m.dryRun {
return
}
// All done, update version wtih current one
vrs := engine.Versions{utils.Actions: engine.CurrentStorDBVersions()[utils.Actions]}
if err = m.dmOut.DataManager().DataDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating Actions version into dataDB", err.Error()))
}
return
}
@@ -121,15 +120,9 @@ func (m *Migrator) migrateActions() (err error) {
if m.sameDataDB {
return
}
if err := m.migrateCurrentActions(); err != nil {
return err
}
return
return m.migrateCurrentActions()
case 1:
if err := m.migrateV1Actions(); err != nil {
return err
}
return m.migrateV1Actions()
}
return
}

64
migrator/action_plan.go
View File

@@ -59,17 +59,16 @@ func (m *Migrator) migrateCurrentActionPlans() (err error) {
if err != nil {
return err
}
if acts != nil {
if m.dryRun != true {
if err := m.dmOut.DataManager().DataDB().SetActionPlan(idg, acts, true, utils.NonTransactional); err != nil {
return err
}
if err := m.dmIN.DataManager().DataDB().RemoveActionPlan(idg, utils.NonTransactional); err != nil {
return err
}
m.stats[utils.ActionPlans] += 1
}
if acts == nil || m.dryRun {
continue
}
if err := m.dmOut.DataManager().DataDB().SetActionPlan(idg, acts, true, utils.NonTransactional); err != nil {
return err
}
if err := m.dmIN.DataManager().DataDB().RemoveActionPlan(idg, utils.NonTransactional); err != nil {
return err
}
m.stats[utils.ActionPlans] += 1
}
return
}
@@ -84,27 +83,27 @@ func (m *Migrator) migrateV1ActionPlans() (err error) {
if err == utils.ErrNoMoreData {
break
}
if *v1APs != nil {
for _, v1ap := range *v1APs {
ap := v1ap.AsActionPlan()
if m.dryRun != true {
if err = m.dmOut.DataManager().DataDB().SetActionPlan(ap.Id, ap, true, utils.NonTransactional); err != nil {
return err
}
m.stats[utils.ActionPlans] += 1
}
if *v1APs == nil || m.dryRun {
continue
}
for _, v1ap := range *v1APs {
ap := v1ap.AsActionPlan()
if err = m.dmOut.DataManager().DataDB().SetActionPlan(ap.Id, ap, true, utils.NonTransactional); err != nil {
return err
}
m.stats[utils.ActionPlans] += 1
}
}
if m.dryRun != true {
// All done, update version wtih current one
vrs := engine.Versions{utils.ActionPlans: engine.CurrentDataDBVersions()[utils.ActionPlans]}
if err = m.dmOut.DataManager().DataDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating ActionPlans version into dataDB", err.Error()))
}
if m.dryRun {
return
}
// All done, update version wtih current one
vrs := engine.Versions{utils.ActionPlans: engine.CurrentDataDBVersions()[utils.ActionPlans]}
if err = m.dmOut.DataManager().DataDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating ActionPlans version into dataDB", err.Error()))
}
return
}
@@ -129,14 +128,9 @@ func (m *Migrator) migrateActionPlans() (err error) {
if m.sameDataDB {
return
}
if err := m.migrateCurrentActionPlans(); err != nil {
return err
}
return
return m.migrateCurrentActionPlans()
case 1:
if err := m.migrateV1ActionPlans(); err != nil {
return err
}
return m.migrateV1ActionPlans()
}
return
}

61
migrator/action_trigger.go
View File

@@ -64,12 +64,11 @@ func (m *Migrator) migrateCurrentActionTrigger() (err error) {
if err != nil {
return err
}
if acts != nil {
if m.dryRun != true {
if err := m.dmOut.DataManager().SetActionTriggers(idg, acts, utils.NonTransactional); err != nil {
return err
}
}
if acts == nil || m.dryRun {
continue
}
if err := m.dmOut.DataManager().SetActionTriggers(idg, acts, utils.NonTransactional); err != nil {
return err
}
}
return
@@ -86,29 +85,29 @@ func (m *Migrator) migrateV1ActionTrigger() (err error) {
if err == utils.ErrNoMoreData {
break
}
if *v1ACTs != nil {
for _, v1ac := range *v1ACTs {
act := v1ac.AsActionTrigger()
acts = append(acts, act)
if *v1ACTs == nil || m.dryRun {
continue
}
for _, v1ac := range *v1ACTs {
act := v1ac.AsActionTrigger()
acts = append(acts, act)
}
if !m.dryRun {
if err := m.dmOut.DataManager().SetActionTriggers(acts[0].ID, acts, utils.NonTransactional); err != nil {
return err
}
m.stats[utils.ActionTriggers] += 1
}
}
if err := m.dmOut.DataManager().SetActionTriggers(acts[0].ID, acts, utils.NonTransactional); err != nil {
return err
}
m.stats[utils.ActionTriggers] += 1
}
if !m.dryRun {
// All done, update version wtih current one
vrs := engine.Versions{utils.ActionTriggers: engine.CurrentDataDBVersions()[utils.ActionTriggers]}
if err = m.dmOut.DataManager().DataDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating ActionTriggers version into DataDB", err.Error()))
}
if m.dryRun {
return
}
// All done, update version wtih current one
vrs := engine.Versions{utils.ActionTriggers: engine.CurrentDataDBVersions()[utils.ActionTriggers]}
if err = m.dmOut.DataManager().DataDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating ActionTriggers version into DataDB", err.Error()))
}
return
}
@@ -133,15 +132,9 @@ func (m *Migrator) migrateActionTriggers() (err error) {
if m.sameDataDB {
return
}
if err := m.migrateCurrentActionTrigger(); err != nil {
return err
}
return
return m.migrateCurrentActionTrigger()
case 1:
if err := m.migrateV1ActionTrigger(); err != nil {
return err
}
return m.migrateV1ActionTrigger()
}
return
}

77
migrator/alias.go
View File

@@ -182,83 +182,6 @@ func (m *Migrator) migrateAlias2Attributes() (err error) {
return
}
// func (m *Migrator) migrateV1Alias() (err error) {
// var ids []string
// ids, err = m.dmIN.DataManager().DataDB().GetKeysForPrefix(ALIASES_PREFIX)
// if err != nil {
// return err
// }
// for _, id := range ids {
// idg := strings.TrimPrefix(id, ALIASES_PREFIX)
// usr, err := m.dmIN.DataManager().DataDB().GetAlias(idg, true, utils.NonTransactional)
// if err != nil {
// return err
// }
// if usr == nil || m.dryRun {
// continue
// }
// if err := m.dmOut.DataManager().DataDB().SetAlias(usr, utils.NonTransactional); err != nil {
// return err
// }
// m.stats[utils.Alias] += 1
// }
// return
// }
func (m *Migrator) migrateAlias() (err error) {
return m.migrateAlias2Attributes()
/*
var vrs engine.Versions
current := engine.CurrentDataDBVersions()
vrs, err = m.dmIN.DataManager().DataDB().GetVersions("")
if err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when querying oldDataDB for versions", err.Error()))
} else if len(vrs) == 0 {
return utils.NewCGRError(utils.Migrator,
utils.MandatoryIEMissingCaps,
utils.UndefinedVersion,
"version number is not defined for ActionTriggers model")
}
switch vrs[Alias] {
case current[Alias]:
if m.sameDataDB {
return
}
return utils.ErrNotImplemented
case 1:
return m.migrateAlias2Attributes()
}
return
*/
}
func (m *Migrator) migrateReverseAlias() (err error) {
// var vrs engine.Versions
// current := engine.CurrentDataDBVersions()
// vrs, err = m.dmOut.DataDB().GetVersions("")
// if err != nil {
// return utils.NewCGRError(utils.Migrator,
// utils.ServerErrorCaps,
// err.Error(),
// fmt.Sprintf("error: <%s> when querying oldDataDB for versions", err.Error()))
// } else if len(vrs) == 0 {
// return utils.NewCGRError(utils.Migrator,
// utils.MandatoryIEMissingCaps,
// utils.UndefinedVersion,
// "version number is not defined for ActionTriggers model")
// }
// switch vrs[utils.ReverseAlias] {
// case current[utils.ReverseAlias]:
// if m.sameDataDB {
// return
// }
// if err := m.migrateCurrentReverseAlias(); err != nil {
// return err
// }
// return
// }
return
}

175
migrator/alias_it_test.go
View File

@@ -36,7 +36,6 @@ var (
alsCfgIn *config.CGRConfig
alsCfgOut *config.CGRConfig
alsMigrator *Migrator
alsAction string
)
var sTestsAlsIT = []func(t *testing.T){
@@ -47,41 +46,22 @@ var sTestsAlsIT = []func(t *testing.T){
func TestAliasMigrateITRedis(t *testing.T) {
inPath := path.Join(*dataDir, "conf", "samples", "tutmysql")
testStart("TestAliasMigrateITRedis", inPath, inPath, utils.Migrate, t)
testStart("TestAliasMigrateITRedis", inPath, inPath, t)
}
func TestAliasMigrateITMongo(t *testing.T) {
inPath := path.Join(*dataDir, "conf", "samples", "tutmongo")
testStart("TestAliasMigrateITMongo", inPath, inPath, utils.Migrate, t)
}
func TestAliasITMove(t *testing.T) {
inPath := path.Join(*dataDir, "conf", "samples", "tutmongo")
outPath := path.Join(*dataDir, "conf", "samples", "tutmysql")
testStart("TestAliasITMove", inPath, outPath, utils.Move, t)
testStart("TestAliasMigrateITMongo", inPath, inPath, t)
}
func TestAliasITMigrateMongo2Redis(t *testing.T) {
inPath := path.Join(*dataDir, "conf", "samples", "tutmongo")
outPath := path.Join(*dataDir, "conf", "samples", "tutmysql")
testStart("TestAliasITMigrateMongo2Redis", inPath, outPath, utils.Migrate, t)
testStart("TestAliasITMigrateMongo2Redis", inPath, outPath, t)
}
func TestAliasITMoveEncoding(t *testing.T) {
inPath := path.Join(*dataDir, "conf", "samples", "tutmongo")
outPath := path.Join(*dataDir, "conf", "samples", "tutmongojson")
testStart("TestAliasITMoveEncoding", inPath, outPath, utils.Move, t)
}
func TestAliasITMoveEncoding2(t *testing.T) {
inPath := path.Join(*dataDir, "conf", "samples", "tutmysql")
outPath := path.Join(*dataDir, "conf", "samples", "tutmysqljson")
testStart("TestAliasITMoveEncoding2", inPath, outPath, utils.Move, t)
}
func testStart(testName, inPath, outPath, action string, t *testing.T) {
func testStart(testName, inPath, outPath string, t *testing.T) {
var err error
alsAction = action
if alsCfgIn, err = config.NewCGRConfigFromFolder(inPath); err != nil {
t.Fatal(err)
}
@@ -176,96 +156,65 @@ func testAlsITMigrateAndMove(t *testing.T) {
Weight: 20,
}
attrProf.Compile()
switch alsAction {
case utils.Migrate:
err := alsMigrator.dmIN.setV1Alias(alias)
if err != nil {
t.Error("Error when setting v1 Alias ", err.Error())
}
currentVersion := engine.Versions{Alias: 1}
err = alsMigrator.dmIN.DataManager().DataDB().SetVersions(currentVersion, false)
if err != nil {
t.Error("Error when setting version for Alias ", err.Error())
}
//check if version was set correctly
if vrs, err := alsMigrator.dmIN.DataManager().DataDB().GetVersions(""); err != nil {
t.Error(err)
} else if vrs[Alias] != 1 {
t.Errorf("Unexpected version returned: %d", vrs[Alias])
}
//migrate alias
err, _ = alsMigrator.Migrate([]string{MetaAliases})
if err != nil {
t.Error("Error when migrating Alias ", err.Error())
}
//check if version was updated
if vrs, err := alsMigrator.dmOut.DataManager().DataDB().GetVersions(""); err != nil {
t.Error(err)
} else if vrs[Alias] != 0 {
t.Errorf("Unexpected version returned: %d", vrs[Alias])
}
//check if alias was migrate correctly
result, err := alsMigrator.dmOut.DataManager().DataDB().GetAttributeProfileDrv("cgrates.org", alias.GetId())
if err != nil {
t.Fatalf("Error when getting Attributes %v", err.Error())
}
result.Compile()
sort.Slice(result.Attributes, func(i, j int) bool {
if result.Attributes[i].FieldName == result.Attributes[j].FieldName {
return result.Attributes[i].FilterIDs[0] < result.Attributes[j].FilterIDs[0]
}
return result.Attributes[i].FieldName < result.Attributes[j].FieldName
}) // only for test; map returns random keys
if !reflect.DeepEqual(*attrProf, *result) {
t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(attrProf), utils.ToJSON(result))
}
//check if old account was deleted
if _, err = alsMigrator.dmIN.getV1Alias(); err != utils.ErrNoMoreData {
t.Error("Error should be not found : ", err)
}
expAlsIdx := map[string]utils.StringMap{
"*string:~Account:1001": utils.StringMap{
"*out:*any:*any:1001:call_1001:*rated": true,
},
"*string:~Subject:call_1001": utils.StringMap{
"*out:*any:*any:1001:call_1001:*rated": true,
},
err := alsMigrator.dmIN.setV1Alias(alias)
if err != nil {
t.Error("Error when setting v1 Alias ", err.Error())
}
currentVersion := engine.Versions{Alias: 1}
err = alsMigrator.dmIN.DataManager().DataDB().SetVersions(currentVersion, false)
if err != nil {
t.Error("Error when setting version for Alias ", err.Error())
}
//check if version was set correctly
if vrs, err := alsMigrator.dmIN.DataManager().DataDB().GetVersions(""); err != nil {
t.Error(err)
} else if vrs[Alias] != 1 {
t.Errorf("Unexpected version returned: %d", vrs[Alias])
}
//migrate alias
err, _ = alsMigrator.Migrate([]string{MetaAliases})
if err != nil {
t.Error("Error when migrating Alias ", err.Error())
}
//check if version was updated
if vrs, err := alsMigrator.dmOut.DataManager().DataDB().GetVersions(""); err != nil {
t.Error(err)
} else if vrs[Alias] != 0 {
t.Errorf("Unexpected version returned: %d", vrs[Alias])
}
//check if alias was migrate correctly
result, err := alsMigrator.dmOut.DataManager().DataDB().GetAttributeProfileDrv("cgrates.org", alias.GetId())
if err != nil {
t.Fatalf("Error when getting Attributes %v", err.Error())
}
result.Compile()
sort.Slice(result.Attributes, func(i, j int) bool {
if result.Attributes[i].FieldName == result.Attributes[j].FieldName {
return result.Attributes[i].FilterIDs[0] < result.Attributes[j].FilterIDs[0]
}
if alsidx, err := alsMigrator.dmOut.DataManager().GetFilterIndexes(utils.PrefixToIndexCache[utils.AttributeProfilePrefix],
utils.ConcatenatedKey("cgrates.org", utils.META_ANY), utils.MetaString, nil); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(expAlsIdx, alsidx) {
t.Errorf("Expected %v, recived: %v", utils.ToJSON(expAlsIdx), utils.ToJSON(alsidx))
}
case utils.Move:
/* // No Move tests
if err := alsMigrator.dmIN.DataManager().DataDB().SetAlias(alias, utils.NonTransactional); err != nil {
t.Error(err)
}
currentVersion := engine.CurrentDataDBVersions()
err := alsMigrator.dmOut.DataManager().DataDB().SetVersions(currentVersion, false)
if err != nil {
t.Error("Error when setting version for Alias ", err.Error())
}
//migrate accounts
err, _ = alsMigrator.Migrate([]string{MetaAliases})
if err != nil {
t.Error("Error when alsMigratorrating Alias ", err.Error())
}
//check if account was migrate correctly
result, err := alsMigrator.dmOut.DataManager().DataDB().GetAlias(alias.GetId(), false)
if err != nil {
t.Error(err)
}
if !reflect.DeepEqual(alias, result) {
t.Errorf("Expecting: %+v, received: %+v", alias, result)
}
//check if old account was deleted
result, err = alsMigrator.dmIN.DataManager().DataDB().GetAlias(alias.GetId(), false)
if err != utils.ErrNotFound {
t.Error(err)
}
// */
return result.Attributes[i].FieldName < result.Attributes[j].FieldName
}) // only for test; map returns random keys
if !reflect.DeepEqual(*attrProf, *result) {
t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(attrProf), utils.ToJSON(result))
}
//check if old account was deleted
if _, err = alsMigrator.dmIN.getV1Alias(); err != utils.ErrNoMoreData {
t.Error("Error should be not found : ", err)
}
expAlsIdx := map[string]utils.StringMap{
"*string:~Account:1001": utils.StringMap{
"*out:*any:*any:1001:call_1001:*rated": true,
},
"*string:~Subject:call_1001": utils.StringMap{
"*out:*any:*any:1001:call_1001:*rated": true,
},
}
if alsidx, err := alsMigrator.dmOut.DataManager().GetFilterIndexes(utils.PrefixToIndexCache[utils.AttributeProfilePrefix],
utils.ConcatenatedKey("cgrates.org", utils.META_ANY), utils.MetaString, nil); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(expAlsIdx, alsidx) {
t.Errorf("Expected %v, recived: %v", utils.ToJSON(expAlsIdx), utils.ToJSON(alsidx))
}
}

132
migrator/attributes.go
View File

@@ -57,18 +57,17 @@ func (m *Migrator) migrateCurrentAttributeProfile() (err error) {
if err != nil {
return err
}
if attrPrf != nil {
if m.dryRun != true {
if err := m.dmOut.DataManager().SetAttributeProfile(attrPrf, true); err != nil {
return err
}
if err := m.dmIN.DataManager().RemoveAttributeProfile(tenant,
idg, utils.NonTransactional, false); err != nil {
return err
}
m.stats[utils.Attributes] += 1
}
if attrPrf == nil || m.dryRun {
continue
}
if err := m.dmOut.DataManager().SetAttributeProfile(attrPrf, true); err != nil {
return err
}
if err := m.dmIN.DataManager().RemoveAttributeProfile(tenant,
idg, utils.NonTransactional, false); err != nil {
return err
}
m.stats[utils.Attributes] += 1
}
return
}
@@ -83,31 +82,34 @@ func (m *Migrator) migrateV1Attributes() (err error) {
if err == utils.ErrNoMoreData {
break
}
if v1Attr != nil {
attrPrf, err := v1Attr.AsAttributeProfile()
if err != nil {
return err
}
if m.dryRun != true {
if err := m.dmOut.DataManager().DataDB().SetAttributeProfileDrv(attrPrf); err != nil {
return err
}
if err := m.dmOut.DataManager().SetAttributeProfile(attrPrf, true); err != nil {
return err
}
m.stats[utils.Attributes] += 1
}
if v1Attr == nil {
continue
}
attrPrf, err := v1Attr.AsAttributeProfile()
if err != nil {
return err
}
if m.dryRun {
continue
}
if err := m.dmOut.DataManager().DataDB().SetAttributeProfileDrv(attrPrf); err != nil {
return err
}
if err := m.dmOut.DataManager().SetAttributeProfile(attrPrf, true); err != nil {
return err
}
m.stats[utils.Attributes] += 1
}
if m.dryRun != true {
// All done, update version wtih current one
vrs := engine.Versions{utils.Attributes: engine.CurrentDataDBVersions()[utils.Attributes]}
if err = m.dmOut.DataManager().DataDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating Thresholds version into dataDB", err.Error()))
}
if m.dryRun {
return
}
// All done, update version wtih current one
vrs := engine.Versions{utils.Attributes: engine.CurrentDataDBVersions()[utils.Attributes]}
if err = m.dmOut.DataManager().DataDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating Thresholds version into dataDB", err.Error()))
}
return
}
@@ -122,31 +124,34 @@ func (m *Migrator) migrateV2Attributes() (err error) {
if err == utils.ErrNoMoreData {
break
}
if v2Attr != nil {
attrPrf, err := v2Attr.AsAttributeProfile()
if err != nil {
return err
}
if m.dryRun != true {
if err := m.dmOut.DataManager().SetAttributeProfile(attrPrf, true); err != nil {
return err
}
if err := m.dmIN.remV2AttributeProfile(v2Attr.Tenant, v2Attr.ID); err != nil {
return err
}
m.stats[utils.Attributes] += 1
}
if v2Attr == nil {
continue
}
attrPrf, err := v2Attr.AsAttributeProfile()
if err != nil {
return err
}
if m.dryRun {
continue
}
if err := m.dmOut.DataManager().SetAttributeProfile(attrPrf, true); err != nil {
return err
}
if err := m.dmIN.remV2AttributeProfile(v2Attr.Tenant, v2Attr.ID); err != nil {
return err
}
m.stats[utils.Attributes] += 1
}
if m.dryRun != true {
// All done, update version wtih current one
vrs := engine.Versions{utils.Attributes: engine.CurrentDataDBVersions()[utils.Attributes]}
if err = m.dmOut.DataManager().DataDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating Thresholds version into dataDB", err.Error()))
}
if m.dryRun {
return
}
// All done, update version wtih current one
vrs := engine.Versions{utils.Attributes: engine.CurrentDataDBVersions()[utils.Attributes]}
if err = m.dmOut.DataManager().DataDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating Thresholds version into dataDB", err.Error()))
}
return
}
@@ -171,18 +176,11 @@ func (m *Migrator) migrateAttributeProfile() (err error) {
if m.sameDataDB {
return
}
if err := m.migrateCurrentAttributeProfile(); err != nil {
return err
}
return
return m.migrateCurrentAttributeProfile()
case 1:
if err := m.migrateV1Attributes(); err != nil {
return err
}
return m.migrateV1Attributes()
case 2:
if err := m.migrateV2Attributes(); err != nil {
return err
}
return m.migrateV2Attributes()
}
return
}

42
migrator/cdrs.go
View File

@@ -60,13 +60,9 @@ func (m *Migrator) migrateCDRs() (err error) {
}
switch vrs[utils.CDRs] {
case 1:
if err := m.migrateV1CDRs(); err != nil {
return err
}
return m.migrateV1CDRs()
case current[utils.CDRs]:
if err := m.migrateCurrentCDRs(); err != nil {
return err
}
return m.migrateCurrentCDRs()
}
return
}
@@ -81,25 +77,25 @@ func (m *Migrator) migrateV1CDRs() (err error) {
if err == utils.ErrNoMoreData {
break
}
if v1CDR != nil {
cdr := v1CDR.V1toV2Cdr()
if m.dryRun != true {
if err = m.storDBOut.StorDB().SetCDR(cdr, true); err != nil {
return err
}
m.stats[utils.CDRs] += 1
}
if v1CDR == nil || m.dryRun {
continue
}
cdr := v1CDR.V1toV2Cdr()
if err = m.storDBOut.StorDB().SetCDR(cdr, true); err != nil {
return err
}
m.stats[utils.CDRs] += 1
}
if m.dryRun != true {
// All done, update version wtih current one
vrs := engine.Versions{utils.CDRs: engine.CurrentStorDBVersions()[utils.CDRs]}
if err = m.storDBOut.StorDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating CDRs version into StorDB", err.Error()))
}
if m.dryRun {
return
}
// All done, update version wtih current one
vrs := engine.Versions{utils.CDRs: engine.CurrentStorDBVersions()[utils.CDRs]}
if err = m.storDBOut.StorDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating CDRs version into StorDB", err.Error()))
}
return
}

18
migrator/chargers.go
View File

@@ -40,14 +40,13 @@ func (m *Migrator) migrateCurrentCharger() (err error) {
if err != nil {
return err
}
if cpp != nil {
if m.dryRun != true {
if err := m.dmOut.DataManager().SetChargerProfile(cpp, true); err != nil {
return err
}
m.stats[utils.Chargers] += 1
}
if cpp == nil || m.dryRun {
continue
}
if err := m.dmOut.DataManager().SetChargerProfile(cpp, true); err != nil {
return err
}
m.stats[utils.Chargers] += 1
}
return
}
@@ -72,10 +71,7 @@ func (m *Migrator) migrateChargers() (err error) {
if m.sameDataDB {
return
}
if err := m.migrateCurrentCharger(); err != nil {
return err
}
return
return m.migrateCurrentCharger()
}
return
}

216
migrator/costdetails.go
View File

@@ -1,216 +0,0 @@
/*
Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
Copyright (C) ITsysCOM GmbH
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>
*/
package migrator
/*
import (
"database/sql"
"encoding/json"
"fmt"
"log"
"time"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
func (m *Migrator) migrateCostDetails() (err error) {
if m.storDBOut == nil {
return utils.NewCGRError(utils.Migrator,
utils.MandatoryIEMissingCaps,
utils.NoStorDBConnection,
"no connection to StorDB")
}
vrs, err := m.storDBOut.StorDB().GetVersions(utils.COST_DETAILS)
if err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when querying storDB for versions", err.Error()))
} else if len(vrs) == 0 {
return utils.NewCGRError(utils.Migrator,
utils.MandatoryIEMissingCaps,
utils.UndefinedVersion,
"version number is not defined for CostDetails model")
}
if vrs[utils.COST_DETAILS] != 1 { // Right now we only support migrating from version 1
log.Print("Wrong version")
return
}
var storSQL *sql.DB
switch m.storDBType {
case utils.MYSQL:
storSQL = m.storDBOut.(*engine.SQLStorage).Db
case utils.POSTGRES:
storSQL = m.storDBOut.(*engine.SQLStorage).Db
default:
return utils.NewCGRError(utils.Migrator,
utils.MandatoryIEMissingCaps,
utils.UnsupportedDB,
fmt.Sprintf("unsupported database type: <%s>", m.storDBType))
}
rows, err := storSQL.Query("SELECT id, tor, direction, tenant, category, account, subject, destination, cost, cost_details FROM cdrs")
if err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when querying storDB for cdrs", err.Error()))
}
defer rows.Close()
for cnt := 0; rows.Next(); cnt++ {
var id int64
var ccDirection, ccCategory, ccTenant, ccSubject, ccAccount, ccDestination, ccTor sql.NullString
var ccCost sql.NullFloat64
var tts []byte
if err := rows.Scan(&id, &ccTor, &ccDirection, &ccTenant, &ccCategory, &ccAccount, &ccSubject, &ccDestination, &ccCost, &tts); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when scanning at count: <%d>", err.Error(), cnt))
}
var v1tmsps v1TimeSpans
if err := json.Unmarshal(tts, &v1tmsps); err != nil {
utils.Logger.Warning(
fmt.Sprintf("<Migrator> Unmarshalling timespans at CDR with id: <%d>, error: <%s>", id, err.Error()))
continue
}
v1CC := &v1CallCost{Direction: ccDirection.String, Category: ccCategory.String, Tenant: ccTenant.String,
Subject: ccSubject.String, Account: ccAccount.String, Destination: ccDestination.String, TOR: ccTor.String,
Cost: ccCost.Float64, Timespans: v1tmsps}
cc := v1CC.AsCallCost()
if cc == nil {
utils.Logger.Warning(
fmt.Sprintf("<Migrator> Error: <%s> when converting into CallCost CDR with id: <%d>", err.Error(), id))
continue
}
if m.dryRun != true {
if _, err := storSQL.Exec(fmt.Sprintf("UPDATE cdrs SET cost_details='%s' WHERE id=%d", cc.AsJSON(), id)); err != nil {
utils.Logger.Warning(
fmt.Sprintf("<Migrator> Error: <%s> updating CDR with id <%d> into StorDB", err.Error(), id))
continue
}
m.stats[utils.COST_DETAILS] += 1
// All done, update version wtih current one
vrs = engine.Versions{utils.COST_DETAILS: engine.CurrentStorDBVersions()[utils.COST_DETAILS]}
if err := m.storDBOut.SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating CostDetails version into StorDB", err.Error()))
}
}
}
return
}
type v1CallCost struct {
Direction, Category, Tenant, Subject, Account, Destination, TOR string
Cost float64
Timespans v1TimeSpans
}
type v1TimeSpans []*v1TimeSpan
type v1TimeSpan struct {
TimeStart, TimeEnd time.Time
Cost float64
RateInterval *engine.RateInterval
DurationIndex time.Duration
Increments v1Increments
MatchedSubject, MatchedPrefix, MatchedDestId, RatingPlanId string
}
type v1Increments []*v1Increment
type v1Increment struct {
Duration time.Duration
Cost float64
BalanceRateInterval *engine.RateInterval
BalanceInfo *v1BalanceInfo
UnitInfo *v1UnitInfo
CompressFactor int
}
type v1BalanceInfo struct {
UnitBalanceUuid string
MoneyBalanceUuid string
AccountId string // used when debited from shared balance
}
type v1UnitInfo struct {
DestinationId string
Quantity float64
TOR string
}
func (v1cc *v1CallCost) AsCallCost() (cc *engine.CallCost) {
cc = new(engine.CallCost)
cc.Direction = v1cc.Direction
cc.Category = v1cc.Category
cc.Tenant = v1cc.Tenant
cc.Account = v1cc.Account
cc.Subject = v1cc.Subject
cc.Destination = v1cc.Destination
cc.TOR = v1cc.TOR
cc.Cost = v1cc.Cost
cc.Timespans = make(engine.TimeSpans, len(v1cc.Timespans))
for i, v1ts := range v1cc.Timespans {
cc.Timespans[i] = &engine.TimeSpan{TimeStart: v1ts.TimeStart,
TimeEnd: v1ts.TimeEnd,
Cost: v1ts.Cost,
RateInterval: v1ts.RateInterval,
DurationIndex: v1ts.DurationIndex,
Increments: make(engine.Increments, len(v1ts.Increments)),
MatchedSubject: v1ts.MatchedSubject,
MatchedPrefix: v1ts.MatchedPrefix,
MatchedDestId: v1ts.MatchedDestId,
RatingPlanId: v1ts.RatingPlanId,
}
for j, v1Incrm := range v1ts.Increments {
cc.Timespans[i].Increments[j] = &engine.Increment{
Duration: v1Incrm.Duration,
Cost: v1Incrm.Cost,
CompressFactor: v1Incrm.CompressFactor,
BalanceInfo: &engine.DebitInfo{
AccountID: v1Incrm.BalanceInfo.AccountId,
},
}
if v1Incrm.BalanceInfo.UnitBalanceUuid != "" {
cc.Timespans[i].Increments[j].BalanceInfo.Unit = &engine.UnitInfo{
UUID: v1Incrm.BalanceInfo.UnitBalanceUuid,
Value: v1Incrm.UnitInfo.Quantity,
DestinationID: v1Incrm.UnitInfo.DestinationId,
TOR: v1Incrm.UnitInfo.TOR,
}
} else if v1Incrm.BalanceInfo.MoneyBalanceUuid != "" {
cc.Timespans[i].Increments[j].BalanceInfo.Monetary = &engine.MonetaryInfo{
UUID: v1Incrm.BalanceInfo.MoneyBalanceUuid,
//Value: v1Incrm.UnitInfo.Quantity,
}
}
}
}
return
}
*/

49
migrator/costdetails_test.go
View File

@@ -1,49 +0,0 @@
/*
Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
Copyright (C) ITsysCOM GmbH
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>
*/
package migrator
/*
import (
"encoding/json"
"testing"
)
var v1TmspsStr1 = `[{"TimeStart":"2016-07-28T02:18:49+02:00","TimeEnd":"2016-07-28T02:19:28+02:00","Cost":0.0117,"RateInterval":{"Timing":{"Years":[],"Months":[],"MonthDays":[],"WeekDays":[],"StartTime":"00:00:00","EndTime":""},"Rating":{"ConnectFee":0.0564,"RoundingMethod":"*middle","RoundingDecimals":4,"MaxCost":0,"MaxCostStrategy":"","Rates":[{"GroupIntervalStart":0,"Value":0.0198,"RateIncrement":1000000000,"RateUnit":60000000000}]},"Weight":10},"DurationIndex":39000000000,"Increments":[{"Duration":1000000000,"Cost":0.0003,"BalanceInfo":{"UnitBalanceUuid":"","MoneyBalanceUuid":"c50c201c405defc3807347444efc62da","AccountId":"cgrates.org:dan"},"BalanceRateInterval":null,"UnitInfo":null,"CompressFactor":39}],"MatchedSubject":"*out:cgrates.org:call:dan","MatchedPrefix":"+311","MatchedDestId":"CST_491_DE001","RatingPlanId":"V_RET_1490_01_V"}]`
var v1TmspsStr2 = `[{"TimeStart":"2016-07-28T01:12:19+02:00","TimeEnd":"2016-07-28T01:12:27+02:00","Cost":0.00046875,"RateInterval":{"Timing":{"Years":[],"Months":[],"MonthDays":[],"WeekDays":[],"StartTime":"00:00:00","EndTime":""},"Rating":{"ConnectFee":0,"RoundingMethod":"*middle","RoundingDecimals":4,"MaxCost":0,"MaxCostStrategy":"","Rates":[{"GroupIntervalStart":0,"Value":0.06,"RateIncrement":1000000000,"RateUnit":1024000000000}]},"Weight":10},"DurationIndex":8000000000,"Increments":null,"MatchedSubject":"*out:cgrates.org:data:danb","MatchedPrefix":"+4900","MatchedDestId":"CST_data_DAT01","RatingPlanId":"M_RET_1409_01_D"}]`
func TestV1CostDetailsAsCostDetails1(t *testing.T) {
var v1tmsps v1TimeSpans
if err := json.Unmarshal([]byte(v1TmspsStr1), &v1tmsps); err != nil {
t.Error(err)
}
v1CC := &v1CallCost{Timespans: v1tmsps}
_ = v1CC.AsCallCost()
// ToDo: Test here the content
}
func TestV1CostDetailsAsCostDetails2(t *testing.T) {
var v1tmsps v1TimeSpans
if err := json.Unmarshal([]byte(v1TmspsStr2), &v1tmsps); err != nil {
t.Error(err)
}
v1CC := &v1CallCost{Timespans: v1tmsps}
_ = v1CC.AsCallCost()
}
*/

55
migrator/derived_chargers.go
View File

@@ -212,61 +212,6 @@ func (m *Migrator) migrateV1DerivedChargers() (err error) {
return
}
/*
func (m *Migrator) migrateCurrentDerivedChargers() (err error) {
var ids []string
ids, err = m.dmIN.DataManager().DataDB().GetKeysForPrefix(utils.DERIVEDCHARGERS_PREFIX)
if err != nil {
return err
}
for _, id := range ids {
idg := strings.TrimPrefix(id, utils.DERIVEDCHARGERS_PREFIX)
drc, err := m.dmIN.DataManager().GetDerivedChargers(idg, true, utils.NonTransactional)
if err != nil {
return err
}
if drc != nil {
if m.dryRun != true {
if err := m.dmOut.DataManager().DataDB().SetDerivedChargers(idg, drc, utils.NonTransactional); err != nil {
return err
}
m.stats[utils.DerivedChargersV] += 1
}
}
}
return
}
*/
func (m *Migrator) migrateDerivedChargers() (err error) {
return m.migrateV1DerivedChargers()
/*
var vrs engine.Versions
current := engine.CurrentDataDBVersions()
vrs, err = m.dmIN.DataManager().DataDB().GetVersions("")
if err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when querying oldDataDB for versions", err.Error()))
} else if len(vrs) == 0 {
return utils.NewCGRError(utils.Migrator,
utils.MandatoryIEMissingCaps,
utils.UndefinedVersion,
"version number is not defined for DerivedChargers model")
}
switch vrs[utils.DerivedChargersV] {
case 1:
case current[utils.DerivedChargersV]:
if m.sameDataDB {
return
}
if err := m.migrateCurrentDerivedChargers(); err != nil {
return err
}
return
}
return
*/
}

201
migrator/derived_chargers_it_test.go
View File

@@ -37,7 +37,6 @@ var (
dcCfgIn *config.CGRConfig
dcCfgOut *config.CGRConfig
dcMigrator *Migrator
dcAction string
)
var sTestsDCIT = []func(t *testing.T){
@@ -48,41 +47,22 @@ var sTestsDCIT = []func(t *testing.T){
func TestDerivedChargersVMigrateITRedis(t *testing.T) {
inPath := path.Join(*dataDir, "conf", "samples", "tutmysql")
testStartDC("TestDerivedChargersVMigrateITRedis", inPath, inPath, utils.Migrate, t)
testStartDC("TestDerivedChargersVMigrateITRedis", inPath, inPath, t)
}
func TestDerivedChargersVMigrateITMongo(t *testing.T) {
inPath := path.Join(*dataDir, "conf", "samples", "tutmongo")
testStartDC("TestDerivedChargersVMigrateITMongo", inPath, inPath, utils.Migrate, t)
}
func TestDerivedChargersVITMove(t *testing.T) {
inPath := path.Join(*dataDir, "conf", "samples", "tutmongo")
outPath := path.Join(*dataDir, "conf", "samples", "tutmysql")
testStartDC("TestDerivedChargersVITMove", inPath, outPath, utils.Move, t)
testStartDC("TestDerivedChargersVMigrateITMongo", inPath, inPath, t)
}
func TestDerivedChargersVITMigrateMongo2Redis(t *testing.T) {
inPath := path.Join(*dataDir, "conf", "samples", "tutmongo")
outPath := path.Join(*dataDir, "conf", "samples", "tutmysql")
testStartDC("TestDerivedChargersVITMigrateMongo2Redis", inPath, outPath, utils.Migrate, t)
testStartDC("TestDerivedChargersVITMigrateMongo2Redis", inPath, outPath, t)
}
func TestDerivedChargersVITMoveEncoding(t *testing.T) {
inPath := path.Join(*dataDir, "conf", "samples", "tutmongo")
outPath := path.Join(*dataDir, "conf", "samples", "tutmongojson")
testStartDC("TestDerivedChargersVITMoveEncoding", inPath, outPath, utils.Move, t)
}
func TestDerivedChargersVITMoveEncoding2(t *testing.T) {
inPath := path.Join(*dataDir, "conf", "samples", "tutmysql")
outPath := path.Join(*dataDir, "conf", "samples", "tutmysqljson")
testStartDC("TestDerivedChargersVITMoveEncoding2", inPath, outPath, utils.Move, t)
}
func testStartDC(testName, inPath, outPath, action string, t *testing.T) {
func testStartDC(testName, inPath, outPath string, t *testing.T) {
var err error
dcAction = action
if dcCfgIn, err = config.NewCGRConfigFromFolder(inPath); err != nil {
t.Fatal(err)
}
@@ -193,108 +173,77 @@ func testDCITMigrateAndMove(t *testing.T) {
AttributeIDs: []string{attrProf.ID},
Weight: 10,
}
switch dcAction {
case utils.Migrate:
err := dcMigrator.dmIN.setV1DerivedChargers(derivch)
if err != nil {
t.Error("Error when setting v1 DerivedChargersV ", err.Error())
}
currentVersion := engine.Versions{utils.DerivedChargersV: 1}
err = dcMigrator.dmIN.DataManager().DataDB().SetVersions(currentVersion, false)
if err != nil {
t.Error("Error when setting version for DerivedChargersV ", err.Error())
}
//check if version was set correctly
if vrs, err := dcMigrator.dmIN.DataManager().DataDB().GetVersions(""); err != nil {
t.Error(err)
} else if vrs[utils.DerivedChargersV] != 1 {
t.Errorf("Unexpected version returned: %d", vrs[utils.DerivedChargersV])
}
//migrate derivch
err, _ = dcMigrator.Migrate([]string{utils.MetaDerivedChargersV})
if err != nil {
t.Error("Error when migrating DerivedChargersV ", err.Error())
}
//check if version was updated
if vrs, err := dcMigrator.dmOut.DataManager().DataDB().GetVersions(""); err != nil {
t.Error(err)
} else if vrs[utils.DerivedChargersV] != 0 {
t.Errorf("Unexpected version returned: %d", vrs[utils.DerivedChargersV])
}
//check if derivch was migrate correctly
result, err := dcMigrator.dmOut.DataManager().DataDB().GetAttributeProfileDrv(defaultTenant, attrProf.ID)
if err != nil {
t.Fatalf("Error when getting Attributes %v", err.Error())
}
result.Compile()
sort.Slice(result.Attributes, func(i, j int) bool {
return result.Attributes[i].FieldName < result.Attributes[j].FieldName
}) // only for test; map returns random keys
if !reflect.DeepEqual(*attrProf, *result) {
t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(attrProf), utils.ToJSON(result))
}
result2, err := dcMigrator.dmOut.DataManager().DataDB().GetChargerProfileDrv(defaultTenant, charger.ID)
if err != nil {
t.Fatalf("Error when getting Attributes %v", err.Error())
}
if !reflect.DeepEqual(*charger, *result2) {
t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(charger), utils.ToJSON(result2))
}
//check if old account was deleted
if _, err = dcMigrator.dmIN.getV1DerivedChargers(); err != utils.ErrNoMoreData {
t.Error("Error should be not found : ", err)
}
expDcIdx := map[string]utils.StringMap{
"*string:~Account:1003": utils.StringMap{
"*out:cgrates.org:*any:1003:*any_0": true,
},
}
if dcidx, err := dcMigrator.dmOut.DataManager().GetFilterIndexes(utils.PrefixToIndexCache[utils.AttributeProfilePrefix],
utils.ConcatenatedKey("cgrates.org", utils.MetaChargers), utils.MetaString, nil); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(expDcIdx, dcidx) {
t.Errorf("Expected %v, recived: %v", utils.ToJSON(expDcIdx), utils.ToJSON(dcidx))
}
expDcIdx = map[string]utils.StringMap{
"*string:~Account:1003": utils.StringMap{
"*out:cgrates.org:*any:1003:*any_0": true,
},
}
if dcidx, err := dcMigrator.dmOut.DataManager().GetFilterIndexes(utils.PrefixToIndexCache[utils.ChargerProfilePrefix],
utils.ConcatenatedKey("cgrates.org", utils.MetaChargers),
utils.MetaString, nil); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Errorf("Expected error %v, recived: %v with reply: %v", utils.ErrNotFound, err, utils.ToJSON(dcidx))
}
case utils.Move:
/* // No Move tests
if err := dcMigrator.dmIN.DataManager().DataDB().SetDerivedChargersV(derivch, utils.NonTransactional); err != nil {
t.Error(err)
}
currentVersion := engine.CurrentDataDBVersions()
err := dcMigrator.dmOut.DataManager().DataDB().SetVersions(currentVersion, false)
if err != nil {
t.Error("Error when setting version for DerivedChargersV ", err.Error())
}
//migrate accounts
err, _ = dcMigrator.Migrate([]string{utils.MetaDerivedChargersV})
if err != nil {
t.Error("Error when dcMigratorrating DerivedChargersV ", err.Error())
}
//check if account was migrate correctly
result, err := dcMigrator.dmOut.DataManager().DataDB().GetDerivedChargersV(derivch.GetId(), false)
if err != nil {
t.Error(err)
}
if !reflect.DeepEqual(derivch, result) {
t.Errorf("Expecting: %+v, received: %+v", derivch, result)
}
//check if old account was deleted
result, err = dcMigrator.dmIN.DataManager().DataDB().GetDerivedChargersV(derivch.GetId(), false)
if err != utils.ErrNotFound {
t.Error(err)
}
// */
err := dcMigrator.dmIN.setV1DerivedChargers(derivch)
if err != nil {
t.Error("Error when setting v1 DerivedChargersV ", err.Error())
}
currentVersion := engine.Versions{utils.DerivedChargersV: 1}
err = dcMigrator.dmIN.DataManager().DataDB().SetVersions(currentVersion, false)
if err != nil {
t.Error("Error when setting version for DerivedChargersV ", err.Error())
}
//check if version was set correctly
if vrs, err := dcMigrator.dmIN.DataManager().DataDB().GetVersions(""); err != nil {
t.Error(err)
} else if vrs[utils.DerivedChargersV] != 1 {
t.Errorf("Unexpected version returned: %d", vrs[utils.DerivedChargersV])
}
//migrate derivch
err, _ = dcMigrator.Migrate([]string{utils.MetaDerivedChargersV})
if err != nil {
t.Error("Error when migrating DerivedChargersV ", err.Error())
}
//check if version was updated
if vrs, err := dcMigrator.dmOut.DataManager().DataDB().GetVersions(""); err != nil {
t.Error(err)
} else if vrs[utils.DerivedChargersV] != 0 {
t.Errorf("Unexpected version returned: %d", vrs[utils.DerivedChargersV])
}
//check if derivch was migrate correctly
result, err := dcMigrator.dmOut.DataManager().DataDB().GetAttributeProfileDrv(defaultTenant, attrProf.ID)
if err != nil {
t.Fatalf("Error when getting Attributes %v", err.Error())
}
result.Compile()
sort.Slice(result.Attributes, func(i, j int) bool {
return result.Attributes[i].FieldName < result.Attributes[j].FieldName
}) // only for test; map returns random keys
if !reflect.DeepEqual(*attrProf, *result) {
t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(attrProf), utils.ToJSON(result))
}
result2, err := dcMigrator.dmOut.DataManager().DataDB().GetChargerProfileDrv(defaultTenant, charger.ID)
if err != nil {
t.Fatalf("Error when getting Attributes %v", err.Error())
}
if !reflect.DeepEqual(*charger, *result2) {
t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(charger), utils.ToJSON(result2))
}
//check if old account was deleted
if _, err = dcMigrator.dmIN.getV1DerivedChargers(); err != utils.ErrNoMoreData {
t.Error("Error should be not found : ", err)
}
expDcIdx := map[string]utils.StringMap{
"*string:~Account:1003": utils.StringMap{
"*out:cgrates.org:*any:1003:*any_0": true,
},
}
if dcidx, err := dcMigrator.dmOut.DataManager().GetFilterIndexes(utils.PrefixToIndexCache[utils.AttributeProfilePrefix],
utils.ConcatenatedKey("cgrates.org", utils.META_ANY), utils.MetaString, nil); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(expDcIdx, dcidx) {
t.Errorf("Expected %v, recived: %v", utils.ToJSON(expDcIdx), utils.ToJSON(dcidx))
}
expDcIdx = map[string]utils.StringMap{
"*string:~Account:1003": utils.StringMap{
"*out:cgrates.org:*any:1003:*any_0": true,
},
}
if dcidx, err := dcMigrator.dmOut.DataManager().GetFilterIndexes(utils.PrefixToIndexCache[utils.ChargerProfilePrefix],
utils.ConcatenatedKey("cgrates.org", utils.META_ANY),
utils.MetaString, nil); err == nil || err.Error() != utils.ErrNotFound.Error() {
t.Errorf("Expected error %v, recived: %v with reply: %v", utils.ErrNotFound, err, utils.ToJSON(dcidx))
}
}

57
migrator/destinations.go
View File

@@ -38,14 +38,13 @@ func (m *Migrator) migrateCurrentDestinations() (err error) {
if err != nil {
return err
}
if dst != nil {
if m.dryRun != true {
if err := m.dmOut.DataManager().DataDB().SetDestination(dst, utils.NonTransactional); err != nil {
return err
}
m.stats[utils.Destinations] += 1
}
if dst == nil || m.dryRun {
continue
}
if err := m.dmOut.DataManager().DataDB().SetDestination(dst, utils.NonTransactional); err != nil {
return err
}
m.stats[utils.Destinations] += 1
}
return
}
@@ -70,10 +69,7 @@ func (m *Migrator) migrateDestinations() (err error) {
if m.sameDataDB {
return
}
if err := m.migrateCurrentDestinations(); err != nil {
return err
}
return
return m.migrateCurrentDestinations()
}
return
}
@@ -90,24 +86,24 @@ func (m *Migrator) migrateCurrentReverseDestinations() (err error) {
if err != nil {
return err
}
if rdst != nil {
for _, rdid := range rdst {
rdstn, err := m.dmIN.DataManager().DataDB().GetDestination(rdid, true, utils.NonTransactional)
if err != nil {
return err
}
if rdstn != nil {
if m.dryRun != true {
if err := m.dmOut.DataManager().DataDB().SetDestination(rdstn, utils.NonTransactional); err != nil {
return err
}
if err := m.dmOut.DataManager().DataDB().SetReverseDestination(rdstn, utils.NonTransactional); err != nil {
return err
}
m.stats[utils.ReverseDestinations] += 1
}
}
if rdst == nil {
continue
}
for _, rdid := range rdst {
rdstn, err := m.dmIN.DataManager().DataDB().GetDestination(rdid, true, utils.NonTransactional)
if err != nil {
return err
}
if rdstn == nil || m.dryRun {
continue
}
if err := m.dmOut.DataManager().DataDB().SetDestination(rdstn, utils.NonTransactional); err != nil {
return err
}
if err := m.dmOut.DataManager().DataDB().SetReverseDestination(rdstn, utils.NonTransactional); err != nil {
return err
}
m.stats[utils.ReverseDestinations] += 1
}
}
return
@@ -133,10 +129,7 @@ func (m *Migrator) migrateReverseDestinations() (err error) {
if m.sameDataDB {
return
}
if err := m.migrateCurrentReverseDestinations(); err != nil {
return err
}
return
return m.migrateCurrentReverseDestinations()
}
return
}

26
migrator/dispatchers.go
View File

@@ -40,18 +40,17 @@ func (m *Migrator) migrateCurrentDispatcher() (err error) {
if err != nil {
return err
}
if dpp != nil {
if m.dryRun != true {
if err := m.dmOut.DataManager().SetDispatcherProfile(dpp, true); err != nil {
return err
}
if err := m.dmIN.DataManager().RemoveDispatcherProfile(tenant,
idg, utils.NonTransactional, false); err != nil {
return err
}
m.stats[utils.Dispatchers] += 1
}
if dpp == nil || m.dryRun {
continue
}
if err := m.dmOut.DataManager().SetDispatcherProfile(dpp, true); err != nil {
return err
}
if err := m.dmIN.DataManager().RemoveDispatcherProfile(tenant,
idg, utils.NonTransactional, false); err != nil {
return err
}
m.stats[utils.Dispatchers] += 1
}
return
}
@@ -76,10 +75,7 @@ func (m *Migrator) migrateDispatchers() (err error) {
if m.sameDataDB {
return
}
if err := m.migrateCurrentDispatcher(); err != nil {
return err
}
return
return m.migrateCurrentDispatcher()
}
return
}

5
migrator/dispatchers_it_test.go
View File

@@ -173,14 +173,13 @@ func testDspITMigrateAndMove(t *testing.T) {
dspPrf := &engine.DispatcherProfile{
Tenant: "cgrates.org",
ID: "Dsp1",
FilterIDs: []string{"*string:Accont:1001"},
FilterIDs: []string{"*string:~Accont:1001"},
ActivationInterval: &utils.ActivationInterval{
ActivationTime: time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
ExpiryTime: time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC),
},
Strategy: utils.MetaRandom,
// Hosts: []string{"localhost", "192.168.56.203"},
Weight: 20,
Weight: 20,
}
if err := dspMigrator.dmIN.DataManager().SetDispatcherProfile(dspPrf, false); err != nil {
t.Error(err)

2
migrator/migrator.go
View File

@@ -92,8 +92,6 @@ func (m *Migrator) Migrate(taskIDs []string) (err error, stats map[string]int) {
err = m.migrateCDRs()
case utils.MetaSessionsCosts:
err = m.migrateSessionSCosts()
// case utils.MetaCostDetails:
// err = m.migrateCostDetails()
case utils.MetaAccounts:
err = m.migrateAccounts()
case utils.MetaActionPlans:

1761
migrator/migrator_it_test.go
View File

File diff suppressed because it is too large Load Diff

18
migrator/rating_plan.go
View File

@@ -38,14 +38,13 @@ func (m *Migrator) migrateCurrentRatingPlans() (err error) {
if err != nil {
return err
}
if rp != nil {
if m.dryRun != true {
if err := m.dmOut.DataManager().SetRatingPlan(rp, utils.NonTransactional); err != nil {
return err
}
m.stats[utils.RatingPlan] += 1
}
if rp == nil || m.dryRun {
continue
}
if err := m.dmOut.DataManager().SetRatingPlan(rp, utils.NonTransactional); err != nil {
return err
}
m.stats[utils.RatingPlan] += 1
}
return
}
@@ -70,10 +69,7 @@ func (m *Migrator) migrateRatingPlans() (err error) {
if m.sameDataDB {
return
}
if err := m.migrateCurrentRatingPlans(); err != nil {
return err
}
return
return m.migrateCurrentRatingPlans()
}
return
}

18
migrator/rating_profile.go
View File

@@ -38,14 +38,13 @@ func (m *Migrator) migrateCurrentRatingProfiles() (err error) {
if err != nil {
return err
}
if rp != nil {
if m.dryRun != true {
if err := m.dmOut.DataManager().SetRatingProfile(rp, utils.NonTransactional); err != nil {
return err
}
m.stats[utils.RatingProfile] += 1
}
if rp == nil || m.dryRun {
continue
}
if err := m.dmOut.DataManager().SetRatingProfile(rp, utils.NonTransactional); err != nil {
return err
}
m.stats[utils.RatingProfile] += 1
}
return
}
@@ -70,10 +69,7 @@ func (m *Migrator) migrateRatingProfiles() (err error) {
if m.sameDataDB {
return
}
if err := m.migrateCurrentRatingProfiles(); err != nil {
return err
}
return
return m.migrateCurrentRatingProfiles()
}
return
}

18
migrator/resource.go
View File

@@ -40,14 +40,13 @@ func (m *Migrator) migrateCurrentResource() (err error) {
if err != nil {
return err
}
if res != nil {
if m.dryRun != true {
if err := m.dmOut.DataManager().SetResourceProfile(res, true); err != nil {
return err
}
m.stats[utils.Resource] += 1
}
if res == nil || m.dryRun {
continue
}
if err := m.dmOut.DataManager().SetResourceProfile(res, true); err != nil {
return err
}
m.stats[utils.Resource] += 1
}
return
}
@@ -72,10 +71,7 @@ func (m *Migrator) migrateResources() (err error) {
if m.sameDataDB {
return
}
if err := m.migrateCurrentResource(); err != nil {
return err
}
return
return m.migrateCurrentResource()
}
return
}

64
migrator/session_costs.go
View File

@@ -63,17 +63,11 @@ func (m *Migrator) migrateSessionSCosts() (err error) {
}
switch vrs[utils.SessionSCosts] {
case 0, 1:
if err := m.migrateV1SessionSCosts(); err != nil {
return err
}
return m.migrateV1SessionSCosts()
case 2:
if err := m.migrateV2SessionSCosts(); err != nil {
return err
}
return m.migrateV2SessionSCosts()
case current[utils.SessionSCosts]:
if err := m.migrateCurrentSessionSCost(); err != nil {
return err
}
return m.migrateCurrentSessionSCost()
}
return nil
}
@@ -82,14 +76,15 @@ func (m *Migrator) migrateV1SessionSCosts() (err error) {
if err = m.storDBIn.renameV1SMCosts(); err != nil {
return err
}
if m.dryRun != true {
vrs := engine.Versions{utils.SessionSCosts: 2}
if err = m.storDBOut.StorDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating SessionSCosts version into StorDB", err.Error()))
}
if m.dryRun {
return
}
vrs := engine.Versions{utils.SessionSCosts: 2}
if err = m.storDBOut.StorDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating SessionSCosts version into StorDB", err.Error()))
}
return
}
@@ -104,29 +99,28 @@ func (m *Migrator) migrateV2SessionSCosts() (err error) {
if err == utils.ErrNoMoreData {
break
}
if v2Cost == nil {
if v2Cost == nil || m.dryRun {
continue
}
smCost := v2Cost.V2toV3Cost()
if m.dryRun != true {
if err = m.storDBOut.StorDB().SetSMCost(smCost); err != nil {
return err
}
if err = m.storDBIn.remV2SMCost(v2Cost); err != nil {
return err
}
m.stats[utils.SessionSCosts] += 1
if err = m.storDBOut.StorDB().SetSMCost(smCost); err != nil {
return err
}
if err = m.storDBIn.remV2SMCost(v2Cost); err != nil {
return err
}
m.stats[utils.SessionSCosts] += 1
}
if m.dryRun != true {
// All done, update version wtih current one
vrs := engine.Versions{utils.SessionSCosts: engine.CurrentStorDBVersions()[utils.SessionSCosts]}
if err = m.storDBOut.StorDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating SessionSCosts version into StorDB", err.Error()))
}
if m.dryRun {
return
}
// All done, update version wtih current one
vrs := engine.Versions{utils.SessionSCosts: engine.CurrentStorDBVersions()[utils.SessionSCosts]}
if err = m.storDBOut.StorDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating SessionSCosts version into StorDB", err.Error()))
}
return
}

36
migrator/sharedgroup.go
View File

@@ -44,12 +44,11 @@ func (m *Migrator) migrateCurrentSharedGroups() (err error) {
if err != nil {
return err
}
if sgs != nil {
if m.dryRun != true {
if err := m.dmOut.DataManager().SetSharedGroup(sgs, utils.NonTransactional); err != nil {
return err
}
}
if sgs == nil || m.dryRun {
continue
}
if err := m.dmOut.DataManager().SetSharedGroup(sgs, utils.NonTransactional); err != nil {
return err
}
}
return
@@ -65,15 +64,14 @@ func (m *Migrator) migrateV1SharedGroups() (err error) {
if err == utils.ErrNoMoreData {
break
}
if v1SG != nil {
acnt := v1SG.AsSharedGroup()
if m.dryRun != true {
if err = m.dmOut.DataManager().SetSharedGroup(acnt, utils.NonTransactional); err != nil {
return err
}
m.stats[utils.SharedGroups] += 1
}
if v1SG == nil || m.dryRun {
continue
}
acnt := v1SG.AsSharedGroup()
if err = m.dmOut.DataManager().SetSharedGroup(acnt, utils.NonTransactional); err != nil {
return err
}
m.stats[utils.SharedGroups] += 1
}
// All done, update version wtih current one
vrs := engine.Versions{utils.SharedGroups: engine.CurrentStorDBVersions()[utils.SharedGroups]}
@@ -106,15 +104,9 @@ func (m *Migrator) migrateSharedGroups() (err error) {
if m.sameDataDB {
return
}
if err := m.migrateCurrentSharedGroups(); err != nil {
return err
}
return
return m.migrateCurrentSharedGroups()
case 1:
if err := m.migrateV1SharedGroups(); err != nil {
return err
}
return m.migrateV1SharedGroups()
}
return
}

18
migrator/suppliers.go
View File

@@ -40,14 +40,13 @@ func (m *Migrator) migrateCurrentSupplierProfile() (err error) {
if err != nil {
return err
}
if splp != nil {
if m.dryRun != true {
if err := m.dmOut.DataManager().SetSupplierProfile(splp, true); err != nil {
return err
}
m.stats[utils.Suppliers] += 1
}
if splp == nil || m.dryRun {
continue
}
if err := m.dmOut.DataManager().SetSupplierProfile(splp, true); err != nil {
return err
}
m.stats[utils.Suppliers] += 1
}
return
}
@@ -72,10 +71,7 @@ func (m *Migrator) migrateSupplierProfiles() (err error) {
if m.sameDataDB {
return
}
if err := m.migrateCurrentSupplierProfile(); err != nil {
return err
}
return
return m.migrateCurrentSupplierProfile()
}
return
}

112
migrator/thresholds.go
View File

@@ -61,14 +61,13 @@ func (m *Migrator) migrateCurrentThresholds() (err error) {
if err != nil {
return err
}
if ths != nil {
if m.dryRun != true {
if err := m.dmOut.DataManager().SetThreshold(ths); err != nil {
return err
}
m.stats[utils.Thresholds] += 1
}
if ths == nil || m.dryRun {
continue
}
if err := m.dmOut.DataManager().SetThreshold(ths); err != nil {
return err
}
m.stats[utils.Thresholds] += 1
}
//ThresholdProfiles
ids, err = m.dmIN.DataManager().DataDB().GetKeysForPrefix(utils.ThresholdProfilePrefix)
@@ -81,12 +80,11 @@ func (m *Migrator) migrateCurrentThresholds() (err error) {
if err != nil {
return err
}
if ths != nil {
if m.dryRun != true {
if err := m.dmOut.DataManager().SetThresholdProfile(ths, true); err != nil {
return err
}
}
if ths == nil || m.dryRun {
continue
}
if err := m.dmOut.DataManager().SetThresholdProfile(ths, true); err != nil {
return err
}
}
return
@@ -107,29 +105,31 @@ func (m *Migrator) migrateV2ActionTriggers() (err error) {
if err != nil {
return err
}
if m.dryRun != true {
if err := m.dmOut.DataManager().SetFilter(filter); err != nil {
return err
}
if err := m.dmOut.DataManager().SetThreshold(th); err != nil {
return err
}
if err := m.dmOut.DataManager().SetThresholdProfile(thp, true); err != nil {
return err
}
m.stats[utils.Thresholds] += 1
if m.dryRun {
continue
}
if err := m.dmOut.DataManager().SetFilter(filter); err != nil {
return err
}
if err := m.dmOut.DataManager().SetThreshold(th); err != nil {
return err
}
if err := m.dmOut.DataManager().SetThresholdProfile(thp, true); err != nil {
return err
}
m.stats[utils.Thresholds] += 1
}
}
if m.dryRun != true {
// All done, update version wtih current one
vrs := engine.Versions{utils.Thresholds: engine.CurrentStorDBVersions()[utils.Thresholds]}
if err = m.dmOut.DataManager().DataDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating Thresholds version into dataDB", err.Error()))
}
if m.dryRun {
return
}
// All done, update version wtih current one
vrs := engine.Versions{utils.Thresholds: engine.CurrentStorDBVersions()[utils.Thresholds]}
if err = m.dmOut.DataManager().DataDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating Thresholds version into dataDB", err.Error()))
}
return
}
@@ -144,28 +144,29 @@ func (m *Migrator) migrateV2Thresholds() (err error) {
if err == utils.ErrNoMoreData {
break
}
if v2T != nil {
th := v2T.V2toV3Threshold()
if m.dryRun != true {
if err = m.dmIN.remV2ThresholdProfile(v2T.Tenant, v2T.ID); err != nil {
return err
}
if err = m.dmOut.DataManager().SetThresholdProfile(th, true); err != nil {
return err
}
m.stats[utils.Thresholds] += 1
}
if v2T == nil || m.dryRun {
continue
}
th := v2T.V2toV3Threshold()
if err = m.dmIN.remV2ThresholdProfile(v2T.Tenant, v2T.ID); err != nil {
return err
}
if err = m.dmOut.DataManager().SetThresholdProfile(th, true); err != nil {
return err
}
m.stats[utils.Thresholds] += 1
}
if m.dryRun != true {
// All done, update version wtih current one
vrs := engine.Versions{utils.Thresholds: engine.CurrentDataDBVersions()[utils.Thresholds]}
if err = m.dmOut.DataManager().DataDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating Thresholds version into dataDB", err.Error()))
}
if m.dryRun {
return
}
// All done, update version wtih current one
vrs := engine.Versions{utils.Thresholds: engine.CurrentDataDBVersions()[utils.Thresholds]}
if err = m.dmOut.DataManager().DataDB().SetVersions(vrs, false); err != nil {
return utils.NewCGRError(utils.Migrator,
utils.ServerErrorCaps,
err.Error(),
fmt.Sprintf("error: <%s> when updating Thresholds version into dataDB", err.Error()))
}
return
}
@@ -404,10 +405,9 @@ func (v2T v2Threshold) V2toV3Threshold() (th *engine.ThresholdProfile) {
ActionIDs: v2T.ActionIDs,
Async: v2T.Async,
}
if v2T.Recurrent == true {
th.MaxHits = 1
if v2T.Recurrent {
th.MaxHits = -1
} else {
th.MaxHits = 1
}
return
}

18
migrator/timings.go
View File

@@ -38,14 +38,13 @@ func (m *Migrator) migrateCurrentTiming() (err error) {
if err != nil {
return err
}
if tm != nil {
if m.dryRun != true {
if err := m.dmOut.DataManager().SetTiming(tm); err != nil {
return err
}
m.stats[utils.Timing] += 1
}
if tm == nil || m.dryRun {
continue
}
if err := m.dmOut.DataManager().SetTiming(tm); err != nil {
return err
}
m.stats[utils.Timing] += 1
}
return
}
@@ -70,10 +69,7 @@ func (m *Migrator) migrateTimings() (err error) {
if m.sameDataDB {
return
}
if err := m.migrateCurrentTiming(); err != nil {
return err
}
return
return m.migrateCurrentTiming()
}
return
}

46
migrator/user.go
View File

@@ -121,52 +121,6 @@ func (m *Migrator) migrateV1User2AttributeProfile() (err error) {
return
}
// func (m *Migrator) migrateCurrentUser() (err error) {
// var ids []string
// ids, err = m.dmIN.DataManager().DataDB().GetKeysForPrefix(utils.USERS_PREFIX)
// if err != nil {
// return err
// }
// for _, id := range ids {
// idg := strings.TrimPrefix(id, utils.USERS_PREFIX)
// usr, err := m.dmIN.DataManager().GetUser(idg)
// if err != nil {
// return err
// }
// if usr != nil {
// if m.dryRun != true {
// if err := m.dmOut.DataManager().SetUser(usr); err != nil {
// return err
// }
// m.stats[utils.User] += 1
// }
// }
// }
// return
// }
func (m *Migrator) migrateUser() (err error) {
return m.migrateV1User2AttributeProfile()
/*
var vrs engine.Versions
current := engine.CurrentDataDBVersions()
vrs, err = m.dmIN.DataManager().DataDB().GetVersions("")
if err != nil {
return utils.NewCGRError(utils.Migrator, utils.ServerErrorCaps,
err.Error(), fmt.Sprintf("error: <%s> when querying oldDataDB for versions", err.Error()))
} else if len(vrs) == 0 {
return utils.NewCGRError(utils.Migrator, utils.MandatoryIEMissingCaps,
utils.UndefinedVersion, "version number is not defined for Users model")
}
switch vrs[utils.User] {
case 1:
return m.migrateV1User2AttributeProfile()
case current[utils.User]:
if !m.sameStorDB {
return utils.ErrNotImplemented
// return m.migrateCurrentUser()
}
}
return
*/
}

164
migrator/user_it_test.go
View File

@@ -36,7 +36,6 @@ var (
usrCfgIn *config.CGRConfig
usrCfgOut *config.CGRConfig
usrMigrator *Migrator
usrAction string
)
var sTestsUsrIT = []func(t *testing.T){
@@ -47,41 +46,22 @@ var sTestsUsrIT = []func(t *testing.T){
func TestUserMigrateITRedis(t *testing.T) {
inPath := path.Join(*dataDir, "conf", "samples", "tutmysql")
testUsrStart("TestUserMigrateITRedis", inPath, inPath, utils.Migrate, t)
testUsrStart("TestUserMigrateITRedis", inPath, inPath, t)
}
func TestUserMigrateITMongo(t *testing.T) {
inPath := path.Join(*dataDir, "conf", "samples", "tutmongo")
testUsrStart("TestUserMigrateITMongo", inPath, inPath, utils.Migrate, t)
}
func TestUserITMove(t *testing.T) {
inPath := path.Join(*dataDir, "conf", "samples", "tutmongo")
outPath := path.Join(*dataDir, "conf", "samples", "tutmysql")
testUsrStart("TestUserITMove", inPath, outPath, utils.Move, t)
testUsrStart("TestUserMigrateITMongo", inPath, inPath, t)
}
func TestUserITMigrateMongo2Redis(t *testing.T) {
inPath := path.Join(*dataDir, "conf", "samples", "tutmongo")
outPath := path.Join(*dataDir, "conf", "samples", "tutmysql")
testUsrStart("TestUserITMigrateMongo2Redis", inPath, outPath, utils.Migrate, t)
testUsrStart("TestUserITMigrateMongo2Redis", inPath, outPath, t)
}
func TestUserITMoveEncoding(t *testing.T) {
inPath := path.Join(*dataDir, "conf", "samples", "tutmongo")
outPath := path.Join(*dataDir, "conf", "samples", "tutmongojson")
testUsrStart("TestUserITMoveEncoding", inPath, outPath, utils.Move, t)
}
func TestUserITMoveEncoding2(t *testing.T) {
inPath := path.Join(*dataDir, "conf", "samples", "tutmysql")
outPath := path.Join(*dataDir, "conf", "samples", "tutmysqljson")
testUsrStart("TestUserITMoveEncoding2", inPath, outPath, utils.Move, t)
}
func testUsrStart(testName, inPath, outPath, action string, t *testing.T) {
func testUsrStart(testName, inPath, outPath string, t *testing.T) {
var err error
usrAction = action
if usrCfgIn, err = config.NewCGRConfigFromFolder(inPath); err != nil {
t.Fatal(err)
}
@@ -165,91 +145,59 @@ func testUsrITMigrateAndMove(t *testing.T) {
Weight: 10,
}
attrProf.Compile()
switch usrAction {
case utils.Migrate:
err := usrMigrator.dmIN.setV1User(user)
if err != nil {
t.Error("Error when setting v1 User ", err.Error())
}
currentVersion := engine.Versions{utils.User: 1}
err = usrMigrator.dmIN.DataManager().DataDB().SetVersions(currentVersion, false)
if err != nil {
t.Error("Error when setting version for User ", err.Error())
}
//check if version was set correctly
if vrs, err := usrMigrator.dmIN.DataManager().DataDB().GetVersions(""); err != nil {
t.Error(err)
} else if vrs[utils.User] != 1 {
t.Errorf("Unexpected version returned: %d", vrs[utils.User])
}
//migrate user
err, _ = usrMigrator.Migrate([]string{utils.MetaUsers})
if err != nil {
t.Error("Error when migrating User ", err.Error())
}
//check if version was updated
if vrs, err := usrMigrator.dmOut.DataManager().DataDB().GetVersions(""); err != nil {
t.Error(err)
} else if vrs[utils.User] != 0 {
t.Errorf("Unexpected version returned: %d", vrs[utils.User])
}
//check if user was migrate correctly
result, err := usrMigrator.dmOut.DataManager().DataDB().GetAttributeProfileDrv(defaultTenant, user.UserName)
if err != nil {
t.Fatalf("Error when getting Attributes %v", err.Error())
}
result.Compile()
sort.Slice(result.Attributes, func(i, j int) bool {
return result.Attributes[i].FieldName < result.Attributes[j].FieldName
}) // only for test; map returns random keys
if !reflect.DeepEqual(*attrProf, *result) {
t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(attrProf), utils.ToJSON(result))
}
//check if old account was deleted
if _, err = usrMigrator.dmIN.getV1Alias(); err != utils.ErrNoMoreData {
t.Error("Error should be not found : ", err)
}
expUsrIdx := map[string]utils.StringMap{
"*string:~Account:1002": utils.StringMap{
"1001": true,
},
}
if usridx, err := usrMigrator.dmOut.DataManager().GetFilterIndexes(utils.PrefixToIndexCache[utils.AttributeProfilePrefix],
utils.ConcatenatedKey("cgrates.org", utils.META_ANY), utils.MetaString, nil); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(expUsrIdx, usridx) {
t.Errorf("Expected %v, recived: %v", utils.ToJSON(expUsrIdx), utils.ToJSON(usridx))
}
err := usrMigrator.dmIN.setV1User(user)
if err != nil {
t.Error("Error when setting v1 User ", err.Error())
}
currentVersion := engine.Versions{utils.User: 1}
err = usrMigrator.dmIN.DataManager().DataDB().SetVersions(currentVersion, false)
if err != nil {
t.Error("Error when setting version for User ", err.Error())
}
//check if version was set correctly
if vrs, err := usrMigrator.dmIN.DataManager().DataDB().GetVersions(""); err != nil {
t.Error(err)
} else if vrs[utils.User] != 1 {
t.Errorf("Unexpected version returned: %d", vrs[utils.User])
}
//migrate user
err, _ = usrMigrator.Migrate([]string{utils.MetaUsers})
if err != nil {
t.Error("Error when migrating User ", err.Error())
}
//check if version was updated
if vrs, err := usrMigrator.dmOut.DataManager().DataDB().GetVersions(""); err != nil {
t.Error(err)
} else if vrs[utils.User] != 0 {
t.Errorf("Unexpected version returned: %d", vrs[utils.User])
}
//check if user was migrate correctly
result, err := usrMigrator.dmOut.DataManager().DataDB().GetAttributeProfileDrv(defaultTenant, user.UserName)
if err != nil {
t.Fatalf("Error when getting Attributes %v", err.Error())
}
result.Compile()
sort.Slice(result.Attributes, func(i, j int) bool {
return result.Attributes[i].FieldName < result.Attributes[j].FieldName
}) // only for test; map returns random keys
if !reflect.DeepEqual(*attrProf, *result) {
t.Errorf("Expecting: %+v, received: %+v", utils.ToJSON(attrProf), utils.ToJSON(result))
}
//check if old account was deleted
if _, err = usrMigrator.dmIN.getV1Alias(); err != utils.ErrNoMoreData {
t.Error("Error should be not found : ", err)
}
case utils.Move:
/* // No Move tests
if err := usrMigrator.dmIN.DataManager().DataDB().SetUserDrv(user); err != nil {
t.Error(err)
}
currentVersion := engine.CurrentDataDBVersions()
err := usrMigrator.dmOut.DataManager().DataDB().SetVersions(currentVersion, false)
if err != nil {
t.Error("Error when setting version for User ", err.Error())
}
//migrate accounts
err, _ = usrMigrator.Migrate([]string{utils.MetaUsers})
if err != nil {
t.Error("Error when usrMigratorrating User ", err.Error())
}
//check if account was migrate correctly
result, err := usrMigrator.dmOut.DataManager().DataDB().GetUserDrv(user.GetId(), false)
if err != nil {
t.Error(err)
}
if !reflect.DeepEqual(user, result) {
t.Errorf("Expecting: %+v, received: %+v", user, result)
}
//check if old account was deleted
result, err = usrMigrator.dmIN.DataManager().DataDB().GetUserDrv(user.GetId(), false)
if err != utils.ErrNotFound {
t.Error(err)
}
// */
expUsrIdx := map[string]utils.StringMap{
"*string:~Account:1002": utils.StringMap{
"1001": true,
},
}
if usridx, err := usrMigrator.dmOut.DataManager().GetFilterIndexes(utils.PrefixToIndexCache[utils.AttributeProfilePrefix],
utils.ConcatenatedKey("cgrates.org", utils.META_ANY), utils.MetaString, nil); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(expUsrIdx, usridx) {
t.Errorf("Expected %v, recived: %v", utils.ToJSON(expUsrIdx), utils.ToJSON(usridx))
}
}