diff --git a/cmd/cgr-loader/cgr-loader.go b/cmd/cgr-loader/cgr-loader.go index d55e01a2e..21091df75 100755 --- a/cmd/cgr-loader/cgr-loader.go +++ b/cmd/cgr-loader/cgr-loader.go @@ -67,6 +67,7 @@ var ( loadHistorySize = flag.Int("load_history_size", config.CgrConfig().LoadHistorySize, "Limit the number of records in the load history") timezone = flag.String("timezone", config.CgrConfig().DefaultTimezone, `Timezone for timestamps where not specified <""|UTC|Local|$IANA_TZ_DB>`) disable_reverse = flag.Bool("disable_reverse_mappings", false, "Will disable reverse mappings rebuilding") + remove = flag.Bool("remove", false, "Will remove any data from db that matches data files") ) func main() { @@ -217,107 +218,112 @@ func main() { } else { log.Print("WARNING: Users automatic data reload is disabled!") } - - // write maps to database - if err := tpReader.WriteToDatabase(*flush, *verbose, *disable_reverse); err != nil { - log.Fatal("Could not write to database: ", err) - } - if len(*historyServer) != 0 && *verbose { - log.Print("Wrote history.") - } - var dstIds, revDstIDs, rplIds, rpfIds, actIds, aapIDs, shgIds, alsIds, lcrIds, dcsIds, rspIDs, resIDs, aatIDs, ralsIDs []string - if rater != nil { - dstIds, _ = tpReader.GetLoadedIds(utils.DESTINATION_PREFIX) - revDstIDs, _ = tpReader.GetLoadedIds(utils.REVERSE_DESTINATION_PREFIX) - rplIds, _ = tpReader.GetLoadedIds(utils.RATING_PLAN_PREFIX) - rpfIds, _ = tpReader.GetLoadedIds(utils.RATING_PROFILE_PREFIX) - actIds, _ = tpReader.GetLoadedIds(utils.ACTION_PREFIX) - aapIDs, _ = tpReader.GetLoadedIds(utils.AccountActionPlansPrefix) - shgIds, _ = tpReader.GetLoadedIds(utils.SHARED_GROUP_PREFIX) - alsIds, _ = tpReader.GetLoadedIds(utils.ALIASES_PREFIX) - lcrIds, _ = tpReader.GetLoadedIds(utils.LCR_PREFIX) - dcsIds, _ = tpReader.GetLoadedIds(utils.DERIVEDCHARGERS_PREFIX) - rspIDs, _ = tpReader.GetLoadedIds(utils.ResourceProfilesPrefix) - resIDs, _ = tpReader.GetLoadedIds(utils.ResourcesPrefix) - aatIDs, _ = tpReader.GetLoadedIds(utils.ACTION_TRIGGER_PREFIX) - ralsIDs, _ = tpReader.GetLoadedIds(utils.REVERSE_ALIASES_PREFIX) - } - aps, _ := tpReader.GetLoadedIds(utils.ACTION_PLAN_PREFIX) - var statsQueueIds []string - if cdrstats != nil { - statsQueueIds, _ = tpReader.GetLoadedIds(utils.CDR_STATS_PREFIX) - } - var userIds []string - if users != nil { - userIds, _ = tpReader.GetLoadedIds(utils.USERS_PREFIX) - } - // release the reader with it's structures - tpReader.Init() - - // Reload scheduler and cache - if rater != nil { - reply := "" - - // Reload cache first since actions could be calling info from within - if *verbose { - log.Print("Reloading cache") + if !*remove { + // write maps to database + if err := tpReader.WriteToDatabase(*flush, *verbose, *disable_reverse); err != nil { + log.Fatal("Could not write to database: ", err) } - if err = rater.Call("ApierV1.ReloadCache", utils.AttrReloadCache{ArgsCache: utils.ArgsCache{ - DestinationIDs: &dstIds, - ReverseDestinationIDs: &revDstIDs, - RatingPlanIDs: &rplIds, - RatingProfileIDs: &rpfIds, - ActionIDs: &actIds, - ActionPlanIDs: &aps, - AccountActionPlanIDs: &aapIDs, - ActionTriggerIDs: &aatIDs, - SharedGroupIDs: &shgIds, - LCRids: &lcrIds, - DerivedChargerIDs: &dcsIds, - AliasIDs: &alsIds, - ReverseAliasIDs: &ralsIDs, - ResourceProfileIDs: &rspIDs, - ResourceIDs: &resIDs}, - FlushAll: *flush, - }, &reply); err != nil { - log.Printf("WARNING: Got error on cache reload: %s\n", err.Error()) + if len(*historyServer) != 0 && *verbose { + log.Print("Wrote history.") } + var dstIds, revDstIDs, rplIds, rpfIds, actIds, aapIDs, shgIds, alsIds, lcrIds, dcsIds, rspIDs, resIDs, aatIDs, ralsIDs []string + if rater != nil { + dstIds, _ = tpReader.GetLoadedIds(utils.DESTINATION_PREFIX) + revDstIDs, _ = tpReader.GetLoadedIds(utils.REVERSE_DESTINATION_PREFIX) + rplIds, _ = tpReader.GetLoadedIds(utils.RATING_PLAN_PREFIX) + rpfIds, _ = tpReader.GetLoadedIds(utils.RATING_PROFILE_PREFIX) + actIds, _ = tpReader.GetLoadedIds(utils.ACTION_PREFIX) + aapIDs, _ = tpReader.GetLoadedIds(utils.AccountActionPlansPrefix) + shgIds, _ = tpReader.GetLoadedIds(utils.SHARED_GROUP_PREFIX) + alsIds, _ = tpReader.GetLoadedIds(utils.ALIASES_PREFIX) + lcrIds, _ = tpReader.GetLoadedIds(utils.LCR_PREFIX) + dcsIds, _ = tpReader.GetLoadedIds(utils.DERIVEDCHARGERS_PREFIX) + rspIDs, _ = tpReader.GetLoadedIds(utils.ResourceProfilesPrefix) + resIDs, _ = tpReader.GetLoadedIds(utils.ResourcesPrefix) + aatIDs, _ = tpReader.GetLoadedIds(utils.ACTION_TRIGGER_PREFIX) + ralsIDs, _ = tpReader.GetLoadedIds(utils.REVERSE_ALIASES_PREFIX) + } + aps, _ := tpReader.GetLoadedIds(utils.ACTION_PLAN_PREFIX) + var statsQueueIds []string + if cdrstats != nil { + statsQueueIds, _ = tpReader.GetLoadedIds(utils.CDR_STATS_PREFIX) + } + var userIds []string + if users != nil { + userIds, _ = tpReader.GetLoadedIds(utils.USERS_PREFIX) + } + // release the reader with it's structures + tpReader.Init() - if len(aps) != 0 { + // Reload scheduler and cache + if rater != nil { + reply := "" + + // Reload cache first since actions could be calling info from within if *verbose { - log.Print("Reloading scheduler") + log.Print("Reloading cache") } - if err = rater.Call("ApierV1.ReloadScheduler", "", &reply); err != nil { - log.Printf("WARNING: Got error on scheduler reload: %s\n", err.Error()) + if err = rater.Call("ApierV1.ReloadCache", utils.AttrReloadCache{ArgsCache: utils.ArgsCache{ + DestinationIDs: &dstIds, + ReverseDestinationIDs: &revDstIDs, + RatingPlanIDs: &rplIds, + RatingProfileIDs: &rpfIds, + ActionIDs: &actIds, + ActionPlanIDs: &aps, + AccountActionPlanIDs: &aapIDs, + ActionTriggerIDs: &aatIDs, + SharedGroupIDs: &shgIds, + LCRids: &lcrIds, + DerivedChargerIDs: &dcsIds, + AliasIDs: &alsIds, + ReverseAliasIDs: &ralsIDs, + ResourceProfileIDs: &rspIDs, + ResourceIDs: &resIDs}, + FlushAll: *flush, + }, &reply); err != nil { + log.Printf("WARNING: Got error on cache reload: %s\n", err.Error()) + } + + if len(aps) != 0 { + if *verbose { + log.Print("Reloading scheduler") + } + if err = rater.Call("ApierV1.ReloadScheduler", "", &reply); err != nil { + log.Printf("WARNING: Got error on scheduler reload: %s\n", err.Error()) + } + } + + } + if cdrstats != nil { + if *flush { + statsQueueIds = []string{} // Force reload all + } + if len(statsQueueIds) != 0 { + if *verbose { + log.Print("Reloading CDRStats data") + } + var reply string + if err := cdrstats.Call("CDRStatsV1.ReloadQueues", utils.AttrCDRStatsReloadQueues{StatsQueueIds: statsQueueIds}, &reply); err != nil { + log.Printf("WARNING: Failed reloading stat queues, error: %s\n", err.Error()) + } } } - } - if cdrstats != nil { - if *flush { - statsQueueIds = []string{} // Force reload all - } - if len(statsQueueIds) != 0 { - if *verbose { - log.Print("Reloading CDRStats data") - } - var reply string - if err := cdrstats.Call("CDRStatsV1.ReloadQueues", utils.AttrCDRStatsReloadQueues{StatsQueueIds: statsQueueIds}, &reply); err != nil { - log.Printf("WARNING: Failed reloading stat queues, error: %s\n", err.Error()) + if users != nil { + if len(userIds) > 0 { + if *verbose { + log.Print("Reloading Users data") + } + var reply string + if err := cdrstats.Call("UsersV1.ReloadUsers", "", &reply); err != nil { + log.Printf("WARNING: Failed reloading users data, error: %s\n", err.Error()) + } + } } - } - - if users != nil { - if len(userIds) > 0 { - if *verbose { - log.Print("Reloading Users data") - } - var reply string - if err := cdrstats.Call("UsersV1.ReloadUsers", "", &reply); err != nil { - log.Printf("WARNING: Failed reloading users data, error: %s\n", err.Error()) - } - + } else { + if err := tpReader.RemoveFromDatabase(*verbose, *disable_reverse); err != nil { + log.Fatal("Could not delete from database: ", err) } } } diff --git a/engine/datamanager.go b/engine/datamanager.go index 3240ee73f..1990cf682 100644 --- a/engine/datamanager.go +++ b/engine/datamanager.go @@ -620,6 +620,19 @@ func (dm *DataManager) SetSharedGroup(sg *SharedGroup, transactionID string) (er } } +func (dm *DataManager) RemoveSharedGroup(id, transactionID string) (err error) { + if dm.DataDB().GetStorageType() == utils.MAPSTOR { + if err = dm.DataDB().RemoveSharedGroupDrv(id, transactionID); err != nil { + return + } + cache.RemKey(utils.SHARED_GROUP_PREFIX+id, cacheCommit(transactionID), transactionID) + return + } else { + return dm.DataDB().RemoveSharedGroupDrv(id, transactionID) + } + +} + func (dm *DataManager) SetLCR(lcr *LCR, transactionID string) (err error) { if dm.DataDB().GetStorageType() == utils.MAPSTOR { if err = dm.DataDB().SetLCRDrv(lcr); err != nil { @@ -631,6 +644,18 @@ func (dm *DataManager) SetLCR(lcr *LCR, transactionID string) (err error) { } } +func (dm *DataManager) RemoveLCR(id, transactionID string) (err error) { + if dm.DataDB().GetStorageType() == utils.MAPSTOR { + if err = dm.DataDB().RemoveLCRDrv(id, transactionID); err != nil { + return + } + cache.RemKey(utils.LCR_PREFIX+id, cacheCommit(transactionID), transactionID) + return + } else { + return dm.DataDB().RemoveLCRDrv(id, transactionID) + } +} + func (dm *DataManager) GetDerivedChargers(key string, skipCache bool, transactionID string) (dcs *utils.DerivedChargers, err error) { cacheKey := utils.DERIVEDCHARGERS_PREFIX + key if !skipCache { @@ -652,6 +677,14 @@ func (dm *DataManager) GetDerivedChargers(key string, skipCache bool, transactio return } +func (dm *DataManager) RemoveDerivedChargers(id, transactionID string) (err error) { + if err = dm.DataDB().RemoveDerivedChargersDrv(id, transactionID); err != nil { + return + } + cache.RemKey(utils.DERIVEDCHARGERS_PREFIX+id, cacheCommit(transactionID), transactionID) + return +} + func (dm *DataManager) GetActions(key string, skipCache bool, transactionID string) (as Actions, err error) { cachekey := utils.ACTION_PREFIX + key if !skipCache { @@ -728,6 +761,14 @@ func (dm *DataManager) SetRatingPlan(rp *RatingPlan, transactionID string) (err } } +func (dm *DataManager) RemoveRatingPlan(key string, transactionID string) (err error) { + if err = dm.DataDB().RemoveRatingPlanDrv(key); err != nil { + return + } + cache.RemKey(utils.RATING_PLAN_PREFIX+key, cacheCommit(transactionID), transactionID) + return +} + func (dm *DataManager) GetRatingProfile(key string, skipCache bool, transactionID string) (rpf *RatingProfile, err error) { cachekey := utils.RATING_PROFILE_PREFIX + key if !skipCache { @@ -809,6 +850,10 @@ func (dm *DataManager) SetReqFilterIndexes(dbKey string, indexes map[string]map[ return dm.DataDB().SetReqFilterIndexesDrv(dbKey, indexes) } +func (dm *DataManager) RemoveReqFilterIndexes(dbKey string) (err error) { + return dm.DataDB().RemoveReqFilterIndexesDrv(dbKey) +} + func (dm *DataManager) MatchReqFilterIndex(dbKey, fieldName, fieldVal string) (itemIDs utils.StringMap, err error) { fieldValKey := utils.ConcatenatedKey(fieldName, fieldVal) cacheKey := dbKey + fieldValKey @@ -837,6 +882,10 @@ func (dm *DataManager) SetCdrStatsQueue(sq *CDRStatsQueue) (err error) { return dm.DataDB().SetCdrStatsQueueDrv(sq) } +func (dm *DataManager) RemoveCdrStatsQueue(key string) error { + return dm.DataDB().RemoveCdrStatsQueueDrv(key) +} + func (dm *DataManager) SetCdrStats(cs *CdrStats) error { return dm.DataDB().SetCdrStatsDrv(cs) } diff --git a/engine/loader_it_test.go b/engine/loader_it_test.go index 23da3e1f7..fbd577dfe 100755 --- a/engine/loader_it_test.go +++ b/engine/loader_it_test.go @@ -79,6 +79,107 @@ func TestLoaderITCreateStorTpTables(t *testing.T) { } } +// Loads data from csv files in tp scenario to dataDbCsv +func TestLoaderITRemoveLoad(t *testing.T) { + /*var err error + for fn, v := range FileValidators { + if err = ValidateCSVData(path.Join(*dataDir, "tariffplans", *tpCsvScenario, fn), v.Rule); err != nil { + t.Error("Failed validating data: ", err.Error()) + } + }*/ + loader = NewTpReader(dataDbCsv.DataDB(), NewFileCSVStorage(utils.CSV_SEP, + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.DESTINATIONS_CSV), + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.TIMINGS_CSV), + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.RATES_CSV), + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.DESTINATION_RATES_CSV), + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.RATING_PLANS_CSV), + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.RATING_PROFILES_CSV), + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.SHARED_GROUPS_CSV), + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.LCRS_CSV), + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.ACTIONS_CSV), + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.ACTION_PLANS_CSV), + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.ACTION_TRIGGERS_CSV), + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.ACCOUNT_ACTIONS_CSV), + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.DERIVED_CHARGERS_CSV), + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.CDR_STATS_CSV), + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.USERS_CSV), + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.ALIASES_CSV), + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.ResourcesCsv), + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.StatsCsv), + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.ThresholdsCsv), + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.FiltersCsv), + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.SuppliersCsv), + path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.AttributesCsv), + ), "", "") + + if err = loader.LoadDestinations(); err != nil { + t.Error("Failed loading destinations: ", err.Error()) + } + if err = loader.LoadTimings(); err != nil { + t.Error("Failed loading timings: ", err.Error()) + } + if err = loader.LoadRates(); err != nil { + t.Error("Failed loading rates: ", err.Error()) + } + if err = loader.LoadDestinationRates(); err != nil { + t.Error("Failed loading destination rates: ", err.Error()) + } + if err = loader.LoadRatingPlans(); err != nil { + t.Error("Failed loading rating plans: ", err.Error()) + } + if err = loader.LoadRatingProfiles(); err != nil { + t.Error("Failed loading rating profiles: ", err.Error()) + } + if err = loader.LoadActions(); err != nil { + t.Error("Failed loading actions: ", err.Error()) + } + if err = loader.LoadActionPlans(); err != nil { + t.Error("Failed loading action timings: ", err.Error()) + } + if err = loader.LoadActionTriggers(); err != nil { + t.Error("Failed loading action triggers: ", err.Error()) + } + if err = loader.LoadAccountActions(); err != nil { + t.Error("Failed loading account actions: ", err.Error()) + } + if err = loader.LoadDerivedChargers(); err != nil { + t.Error("Failed loading derived chargers: ", err.Error()) + } + if err = loader.LoadLCRs(); err != nil { + t.Error("Failed loading lcr rules: ", err.Error()) + } + if err = loader.LoadUsers(); err != nil { + t.Error("Failed loading users: ", err.Error()) + } + if err = loader.LoadAliases(); err != nil { + t.Error("Failed loading aliases: ", err.Error()) + } + if err = loader.LoadFilters(); err != nil { + t.Error("Failed loading filters: ", err.Error()) + } + if err = loader.LoadResourceProfiles(); err != nil { + t.Error("Failed loading resource profiles: ", err.Error()) + } + if err = loader.LoadStats(); err != nil { + t.Error("Failed loading stats: ", err.Error()) + } + if err = loader.LoadThresholds(); err != nil { + t.Error("Failed loading thresholds: ", err.Error()) + } + if err = loader.LoadSupplierProfiles(); err != nil { + t.Error("Failed loading Supplier profiles: ", err.Error()) + } + if err = loader.LoadAttributeProfiles(); err != nil { + t.Error("Failed loading Alias profiles: ", err.Error()) + } + if err := loader.WriteToDatabase(true, false, false); err != nil { + t.Error("Could not write data into dataDb: ", err.Error()) + } + if err := loader.RemoveFromDatabase(false, true); err != nil { + t.Error("Could not write data into dataDb: ", err.Error()) + } +} + // Loads data from csv files in tp scenario to dataDbCsv func TestLoaderITLoadFromCSV(t *testing.T) { /*var err error diff --git a/engine/onstor_it_test.go b/engine/onstor_it_test.go index f5bd7e35b..f797a7431 100644 --- a/engine/onstor_it_test.go +++ b/engine/onstor_it_test.go @@ -191,6 +191,12 @@ func testOnStorITSetGetDerivedCharges(t *testing.T) { } else if !reflect.DeepEqual(rcvCharger, charger1) { t.Errorf("Expecting %v, received: %v", charger1, rcvCharger) } + if err := onStor.RemoveDerivedChargers(keyCharger1, utils.NonTransactional); err != nil { + t.Error(err) + } + if _, rcvErr := onStor.GetDerivedChargers(keyCharger1, false, utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } } func testOnStorITSetReqFilterIndexes(t *testing.T) { @@ -258,6 +264,19 @@ func testOnStorITGetReqFilterIndexes(t *testing.T) { if _, err := onStor.GetReqFilterIndexes("unknown_key"); err == nil || err != utils.ErrNotFound { t.Error(err) } + if err := onStor.RemoveReqFilterIndexes(utils.ResourceProfilesStringIndex); err != nil { + t.Error(err) + } + _, err := onStor.GetReqFilterIndexes(utils.ResourceProfilesStringIndex) + if err != utils.ErrNotFound { + //if err!=nil{ + t.Error(err) + //}else if !reflect.DeepEqual(eIdxes, idxes) { + // t.Errorf("Expecting: %+v, received: %+v", eIdxes, idxes) + } + if err := onStor.SetReqFilterIndexes(utils.ResourceProfilesStringIndex, eIdxes); err != nil { + t.Error(err) + } } func testOnStorITMatchReqFilterIndex(t *testing.T) { @@ -533,6 +552,12 @@ func testOnStorITCacheActionPlan(t *testing.T) { } else if rcv := itm.(*ActionPlan); !reflect.DeepEqual(ap, rcv) { t.Errorf("Expecting: %+v, received: %+v", ap, rcv) } + if err := onStor.DataDB().RemoveActionPlan(ap.Id, utils.NonTransactional); err != nil { + t.Error(err) + } + if err := onStor.DataDB().SetActionPlan(ap.Id, ap, true, utils.NonTransactional); err != nil { + t.Error(err) + } } func testOnStorITCacheAccountActionPlans(t *testing.T) { @@ -1345,6 +1370,13 @@ func testOnStorITCRUDRatingPlan(t *testing.T) { // if err = onStor.DataDB().SelectDatabase(onStorCfg); err != nil { // t.Error(err) // } + if err = onStor.RemoveRatingPlan(rp.Id, utils.NonTransactional); err != nil { + t.Error(err) + } + if _, rcvErr := onStor.GetRatingPlan(rp.Id, true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } + } func testOnStorITCRUDRatingProfile(t *testing.T) { @@ -1534,6 +1566,12 @@ func testOnStorITCRUDLCR(t *testing.T) { // if err = onStor.DataDB().SelectDatabase(onStorCfg); err != nil { // t.Error(err) // } + if err := onStor.RemoveLCR(lcr.GetId(), utils.NonTransactional); err != nil { + t.Error(err) + } + if _, rcvErr := onStor.GetLCR(lcr.GetId(), true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } } func testOnStorITCRUDCdrStats(t *testing.T) { @@ -1671,6 +1709,12 @@ func testOnStorITCRUDSharedGroup(t *testing.T) { // if err = onStor.DataDB().SelectDatabase(onStorCfg); err != nil { // t.Error(err) // } + if err := onStor.RemoveSharedGroup(sg.Id, utils.NonTransactional); err != nil { + t.Error(err) + } + if _, rcvErr := onStor.GetSharedGroup(sg.Id, true, utils.NonTransactional); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } } func testOnStorITCRUDActionTriggers(t *testing.T) { @@ -1897,6 +1941,12 @@ func testOnStorITCRUDCdrStatsQueue(t *testing.T) { } else if !reflect.DeepEqual(sq.Cdrs, rcv.Cdrs) { t.Errorf("Expecting: %v, received: %v", sq.Cdrs, rcv.Cdrs) } + if err := onStor.RemoveCdrStatsQueue(sq.GetId()); err != nil { + t.Error(err) + } + if _, rcvErr := onStor.GetCdrStatsQueue(sq.GetId()); rcvErr != utils.ErrNotFound { + t.Error(rcvErr) + } } func testOnStorITCRUDSubscribers(t *testing.T) { diff --git a/engine/storage_interface.go b/engine/storage_interface.go index d447460b0..74e076559 100755 --- a/engine/storage_interface.go +++ b/engine/storage_interface.go @@ -35,6 +35,7 @@ type Storage interface { Flush(string) error GetKeysForPrefix(string) ([]string, error) RebuildReverseForPrefix(string) error + RemoveReverseForPrefix(string) error GetVersions(itm string) (vrs Versions, err error) SetVersions(vrs Versions, overwrite bool) (err error) RemoveVersions(vrs Versions) (err error) @@ -50,6 +51,7 @@ type DataDB interface { HasDataDrv(string, string) (bool, error) GetRatingPlanDrv(string) (*RatingPlan, error) SetRatingPlanDrv(*RatingPlan) error + RemoveRatingPlanDrv(key string) (err error) GetRatingProfileDrv(string) (*RatingProfile, error) SetRatingProfileDrv(*RatingProfile) error RemoveRatingProfileDrv(string) error @@ -61,21 +63,25 @@ type DataDB interface { UpdateReverseDestination(*Destination, *Destination, string) error GetLCRDrv(string) (*LCR, error) SetLCRDrv(*LCR) error + RemoveLCRDrv(id, transactionID string) (err error) SetCdrStatsDrv(*CdrStats) error GetCdrStatsDrv(string) (*CdrStats, error) GetAllCdrStatsDrv() ([]*CdrStats, error) GetDerivedChargersDrv(string) (*utils.DerivedChargers, error) SetDerivedChargers(string, *utils.DerivedChargers, string) error + RemoveDerivedChargersDrv(id, transactionID string) (err error) GetActionsDrv(string) (Actions, error) SetActionsDrv(string, Actions) error RemoveActionsDrv(string) error GetSharedGroupDrv(string) (*SharedGroup, error) SetSharedGroupDrv(*SharedGroup) error + RemoveSharedGroupDrv(id, transactionID string) (err error) GetActionTriggersDrv(string) (ActionTriggers, error) SetActionTriggersDrv(string, ActionTriggers) error RemoveActionTriggersDrv(string) error GetActionPlan(string, bool, string) (*ActionPlan, error) SetActionPlan(string, *ActionPlan, bool, string) error + RemoveActionPlan(key string, transactionID string) error GetAllActionPlans() (map[string]*ActionPlan, error) GetAccountActionPlans(acntID string, skipCache bool, transactionID string) (apIDs []string, err error) SetAccountActionPlans(acntID string, apIDs []string, overwrite bool) (err error) @@ -87,6 +93,7 @@ type DataDB interface { RemoveAccount(string) error GetCdrStatsQueueDrv(string) (*CDRStatsQueue, error) SetCdrStatsQueueDrv(*CDRStatsQueue) error + RemoveCdrStatsQueueDrv(id string) (err error) GetSubscribersDrv() (map[string]*SubscriberData, error) SetSubscriberDrv(string, *SubscriberData) error RemoveSubscriberDrv(string) error @@ -112,6 +119,7 @@ type DataDB interface { AddLoadHistory(*utils.LoadInstance, int, string) error GetReqFilterIndexesDrv(dbKey string) (indexes map[string]map[string]utils.StringMap, err error) SetReqFilterIndexesDrv(dbKey string, indexes map[string]map[string]utils.StringMap) (err error) + RemoveReqFilterIndexesDrv(id string) (err error) MatchReqFilterIndexDrv(dbKey, fieldName, fieldVal string) (itemIDs utils.StringMap, err error) GetStatQueueProfileDrv(tenant string, ID string) (sq *StatQueueProfile, err error) SetStatQueueProfileDrv(sq *StatQueueProfile) (err error) diff --git a/engine/storage_map.go b/engine/storage_map.go index e2a077a55..bf815d83c 100755 --- a/engine/storage_map.go +++ b/engine/storage_map.go @@ -146,6 +146,54 @@ func (ms *MapStorage) RebuildReverseForPrefix(prefix string) error { return nil } +func (ms *MapStorage) RemoveReverseForPrefix(prefix string) error { + // ToDo: should do transaction + keys, err := ms.GetKeysForPrefix(prefix) + if err != nil { + return err + } + for _, key := range keys { + ms.mu.Lock() + delete(ms.dict, key) + ms.mu.Unlock() + } + switch prefix { + case utils.REVERSE_DESTINATION_PREFIX: + keys, err = ms.GetKeysForPrefix(utils.DESTINATION_PREFIX) + if err != nil { + return err + } + for _, key := range keys { + dest, err := ms.GetDestination(key[len(utils.DESTINATION_PREFIX):], false, utils.NonTransactional) + if err != nil { + return err + } + if err := ms.RemoveDestination(dest.Id, utils.NonTransactional); err != nil { + return err + } + } + case utils.REVERSE_ALIASES_PREFIX: + keys, err = ms.GetKeysForPrefix(utils.ALIASES_PREFIX) + if err != nil { + return err + } + for _, key := range keys { + al, err := ms.GetAlias(key[len(utils.ALIASES_PREFIX):], false, utils.NonTransactional) + if err != nil { + return err + } + if err := ms.RemoveAlias(al.GetId(), utils.NonTransactional); err != nil { + return err + } + } + case utils.AccountActionPlansPrefix: + return nil + default: + return utils.ErrInvalidKey + } + return nil +} + func (ms *MapStorage) IsDBEmpty() (resp bool, err error) { ms.mu.RLock() defer ms.mu.RUnlock() @@ -217,6 +265,22 @@ func (ms *MapStorage) SetRatingPlanDrv(rp *RatingPlan) (err error) { return } +func (ms *MapStorage) RemoveRatingPlanDrv(key string) (err error) { + ms.mu.Lock() + defer ms.mu.Unlock() + for k := range ms.dict { + if strings.HasPrefix(k, key) { + delete(ms.dict, key) + response := 0 + rpf := &RatingPlan{Id: key} + if historyScribe != nil { + go historyScribe.Call("HistoryV1.Record", rpf.GetHistoryRecord(), &response) + } + } + } + return +} + func (ms *MapStorage) GetRatingProfileDrv(key string) (rpf *RatingProfile, err error) { ms.mu.RLock() defer ms.mu.RUnlock() @@ -279,6 +343,13 @@ func (ms *MapStorage) SetLCRDrv(lcr *LCR) (err error) { return } +func (ms *MapStorage) RemoveLCRDrv(id, transactionID string) (err error) { + ms.mu.Lock() + defer ms.mu.Unlock() + delete(ms.dict, utils.LCR_PREFIX+id) + return +} + func (ms *MapStorage) GetDestination(key string, skipCache bool, transactionID string) (dest *Destination, err error) { ms.mu.RLock() defer ms.mu.RUnlock() @@ -495,6 +566,13 @@ func (ms *MapStorage) SetSharedGroupDrv(sg *SharedGroup) (err error) { return } +func (ms *MapStorage) RemoveSharedGroupDrv(id, transactionID string) (err error) { + ms.mu.Lock() + defer ms.mu.Unlock() + delete(ms.dict, utils.SHARED_GROUP_PREFIX+id) + return +} + func (ms *MapStorage) GetAccount(key string) (ub *Account, err error) { ms.mu.RLock() defer ms.mu.RUnlock() @@ -561,6 +639,14 @@ func (ms *MapStorage) SetCdrStatsQueueDrv(sq *CDRStatsQueue) (err error) { return } +func (ms *MapStorage) RemoveCdrStatsQueueDrv(id string) (err error) { + ms.mu.Lock() + defer ms.mu.Unlock() + + delete(ms.dict, id) + return +} + func (ms *MapStorage) GetSubscribersDrv() (result map[string]*SubscriberData, err error) { ms.mu.RLock() defer ms.mu.RUnlock() @@ -847,6 +933,15 @@ func (ms *MapStorage) SetActionPlan(key string, ats *ActionPlan, overwrite bool, return } +func (ms *MapStorage) RemoveActionPlan(key string, transactionID string) error { + cCommit := cacheCommit(transactionID) + ms.mu.Lock() + defer ms.mu.Unlock() + delete(ms.dict, utils.ACTION_PLAN_PREFIX+key) + cache.RemKey(utils.ACTION_PLAN_PREFIX+key, cCommit, transactionID) + return nil +} + func (ms *MapStorage) GetAllActionPlans() (ats map[string]*ActionPlan, err error) { keys, err := ms.GetKeysForPrefix(utils.ACTION_PLAN_PREFIX) if err != nil { @@ -995,6 +1090,15 @@ func (ms *MapStorage) SetDerivedChargers(key string, dcs *utils.DerivedChargers, return err } +func (ms *MapStorage) RemoveDerivedChargersDrv(id, transactionID string) (err error) { + ms.mu.Lock() + defer ms.mu.Unlock() + cCommit := cacheCommit(transactionID) + delete(ms.dict, id) + cache.RemKey(id, cCommit, transactionID) + return +} + func (ms *MapStorage) SetCdrStatsDrv(cs *CdrStats) error { ms.mu.Lock() defer ms.mu.Unlock() @@ -1173,6 +1277,14 @@ func (ms *MapStorage) SetReqFilterIndexesDrv(dbKey string, indexes map[string]ma ms.dict[dbKey] = result return } + +func (ms *MapStorage) RemoveReqFilterIndexesDrv(id string) (err error) { + ms.mu.Lock() + defer ms.mu.Unlock() + delete(ms.dict, id) + return +} + func (ms *MapStorage) MatchReqFilterIndexDrv(dbKey, fldName, fldVal string) (itemIDs utils.StringMap, err error) { ms.mu.RLock() defer ms.mu.RUnlock() diff --git a/engine/storage_mongo_datadb.go b/engine/storage_mongo_datadb.go index 798c6425c..eac9a83fb 100755 --- a/engine/storage_mongo_datadb.go +++ b/engine/storage_mongo_datadb.go @@ -428,6 +428,66 @@ func (ms *MongoStorage) RebuildReverseForPrefix(prefix string) (err error) { return nil } +func (ms *MongoStorage) RemoveReverseForPrefix(prefix string) (err error) { + if !utils.IsSliceMember([]string{utils.REVERSE_DESTINATION_PREFIX, utils.REVERSE_ALIASES_PREFIX, utils.AccountActionPlansPrefix}, prefix) { + return utils.ErrInvalidKey + } + colName, ok := ms.getColNameForPrefix(prefix) + if !ok { + return utils.ErrInvalidKey + } + session, col := ms.conn(colName) + defer session.Close() + if _, err := col.RemoveAll(bson.M{}); err != nil { + return err + } + var keys []string + switch prefix { + case utils.REVERSE_DESTINATION_PREFIX: + if keys, err = ms.GetKeysForPrefix(utils.DESTINATION_PREFIX); err != nil { + return + } + for _, key := range keys { + dest, err := ms.GetDestination(key[len(utils.DESTINATION_PREFIX):], true, utils.NonTransactional) + if err != nil { + return err + } + if err := ms.RemoveDestination(dest.Id, utils.NonTransactional); err != nil { + return err + } + } + case utils.REVERSE_ALIASES_PREFIX: + if keys, err = ms.GetKeysForPrefix(utils.ALIASES_PREFIX); err != nil { + return + } + for _, key := range keys { + al, err := ms.GetAlias(key[len(utils.ALIASES_PREFIX):], true, utils.NonTransactional) + if err != nil { + return err + } + if err := ms.RemoveAlias(al.GetId(), utils.NonTransactional); err != nil { + return err + } + } + case utils.AccountActionPlansPrefix: + if keys, err = ms.GetKeysForPrefix(utils.ACTION_PLAN_PREFIX); err != nil { + return + } + for _, key := range keys { + apl, err := ms.GetActionPlan(key[len(utils.ACTION_PLAN_PREFIX):], true, utils.NonTransactional) + if err != nil { + return err + } + for acntID := range apl.AccountIDs { + if err = ms.RemAccountActionPlans(acntID, []string{apl.Id}); err != nil { + return err + } + } + } + } + return nil +} + func (ms *MongoStorage) IsDBEmpty() (resp bool, err error) { session := ms.session.Copy() defer session.Close() @@ -693,6 +753,39 @@ func (ms *MongoStorage) SetRatingPlanDrv(rp *RatingPlan) error { return err } +func (ms *MongoStorage) RemoveRatingPlanDrv(key string) error { + session, col := ms.conn(colRpl) + defer session.Close() + var kv struct { + Key string + Value []byte + } + var rp RatingPlan + iter := col.Find(bson.M{"key": key}).Iter() + for iter.Next(&kv) { + if err := col.Remove(bson.M{"key": kv.Key}); err != nil { + return err + } + b := bytes.NewBuffer(kv.Value) + r, err := zlib.NewReader(b) + if err != nil { + return err + } + out, err := ioutil.ReadAll(r) + if err != nil { + return err + } + if err = ms.ms.Unmarshal(out, &rp); err != nil { + return err + } + if err == nil && historyScribe != nil { + var response int + go historyScribe.Call("HistoryV1.Record", rp.GetHistoryRecord(), &response) + } + } + return iter.Close() +} + func (ms *MongoStorage) GetRatingProfileDrv(key string) (rp *RatingProfile, err error) { session, col := ms.conn(colRpf) defer session.Close() @@ -766,6 +859,13 @@ func (ms *MongoStorage) SetLCRDrv(lcr *LCR) (err error) { return } +func (ms *MongoStorage) RemoveLCRDrv(id, transactionID string) (err error) { + session, col := ms.conn(colLcr) + defer session.Close() + err = col.Remove(bson.M{"key": id}) + return err +} + func (ms *MongoStorage) GetDestination(key string, skipCache bool, transactionID string) (result *Destination, err error) { cacheKey := utils.DESTINATION_PREFIX + key if !skipCache { @@ -1013,6 +1113,13 @@ func (ms *MongoStorage) SetSharedGroupDrv(sg *SharedGroup) (err error) { return } +func (ms *MongoStorage) RemoveSharedGroupDrv(id, transactionID string) (err error) { + session, col := ms.conn(colShg) + defer session.Close() + err = col.Remove(bson.M{"id": id}) + return err +} + func (ms *MongoStorage) GetAccount(key string) (result *Account, err error) { result = new(Account) session, col := ms.conn(colAcc) @@ -1078,6 +1185,15 @@ func (ms *MongoStorage) SetCdrStatsQueueDrv(sq *CDRStatsQueue) (err error) { return } +func (ms *MongoStorage) RemoveCdrStatsQueueDrv(id string) (err error) { + session, col := ms.conn(colStq) + defer session.Close() + if err = col.Remove(bson.M{"key": id}); err != nil && err != mgo.ErrNotFound { + return + } + return nil +} + func (ms *MongoStorage) GetSubscribersDrv() (result map[string]*SubscriberData, err error) { session, col := ms.conn(colPbs) defer session.Close() @@ -1498,6 +1614,19 @@ func (ms *MongoStorage) SetActionPlan(key string, ats *ActionPlan, overwrite boo return err } +func (ms *MongoStorage) RemoveActionPlan(key string, transactionID string) error { + session, col := ms.conn(colApl) + defer session.Close() + dbKey := utils.ACTION_PLAN_PREFIX + key + cCommit := cacheCommit(transactionID) + cache.RemKey(dbKey, cCommit, transactionID) + err := col.Remove(bson.M{"key": key}) + if err != nil && err == mgo.ErrNotFound { + err = nil + } + return err +} + func (ms *MongoStorage) GetAllActionPlans() (ats map[string]*ActionPlan, err error) { keys, err := ms.GetKeysForPrefix(utils.ACTION_PLAN_PREFIX) if err != nil { @@ -1659,6 +1788,18 @@ func (ms *MongoStorage) SetDerivedChargers(key string, dcs *utils.DerivedCharger return err } +func (ms *MongoStorage) RemoveDerivedChargersDrv(id, transactionID string) (err error) { + cCommit := cacheCommit(transactionID) + cacheKey := utils.DERIVEDCHARGERS_PREFIX + id + session, col := ms.conn(colDcs) + defer session.Close() + if err = col.Remove(bson.M{"key": id}); err != nil && err != mgo.ErrNotFound { + return + } + cache.RemKey(cacheKey, cCommit, transactionID) + return nil +} + func (ms *MongoStorage) SetCdrStatsDrv(cs *CdrStats) error { session, col := ms.conn(colCrs) defer session.Close() @@ -1803,6 +1944,15 @@ func (ms *MongoStorage) SetReqFilterIndexesDrv(dbKey string, indexes map[string] return } +func (ms *MongoStorage) RemoveReqFilterIndexesDrv(id string) (err error) { + session, col := ms.conn(colRFI) + defer session.Close() + if err = col.Remove(bson.M{"key": id}); err != nil { + return + } + return nil +} + func (ms *MongoStorage) MatchReqFilterIndexDrv(dbKey, fldName, fldVal string) (itemIDs utils.StringMap, err error) { session, col := ms.conn(colRFI) defer session.Close() diff --git a/engine/storage_redis.go b/engine/storage_redis.go index 7e309d8c9..a7dcc49eb 100755 --- a/engine/storage_redis.go +++ b/engine/storage_redis.go @@ -191,6 +191,66 @@ func (rs *RedisStorage) RebuildReverseForPrefix(prefix string) (err error) { return nil } +func (rs *RedisStorage) RemoveReverseForPrefix(prefix string) (err error) { + if !utils.IsSliceMember([]string{utils.REVERSE_DESTINATION_PREFIX, utils.REVERSE_ALIASES_PREFIX, utils.AccountActionPlansPrefix}, prefix) { + return utils.ErrInvalidKey + } + var keys []string + keys, err = rs.GetKeysForPrefix(prefix) + if err != nil { + return + } + for _, key := range keys { + if err = rs.Cmd("DEL", key).Err; err != nil { + return + } + } + switch prefix { + case utils.REVERSE_DESTINATION_PREFIX: + if keys, err = rs.GetKeysForPrefix(utils.DESTINATION_PREFIX); err != nil { + return + } + for _, key := range keys { + dest, err := rs.GetDestination(key[len(utils.DESTINATION_PREFIX):], true, utils.NonTransactional) + if err != nil { + return err + } + if err := rs.RemoveDestination(dest.Id, utils.NonTransactional); err != nil { + return err + } + } + case utils.REVERSE_ALIASES_PREFIX: + if keys, err = rs.GetKeysForPrefix(utils.ALIASES_PREFIX); err != nil { + return + } + for _, key := range keys { + al, err := rs.GetAlias(key[len(utils.ALIASES_PREFIX):], true, utils.NonTransactional) + if err != nil { + return err + } + if err := rs.RemoveAlias(al.GetId(), utils.NonTransactional); err != nil { + return err + } + } + case utils.AccountActionPlansPrefix: + if keys, err = rs.GetKeysForPrefix(utils.ACTION_PLAN_PREFIX); err != nil { + return + } + for _, key := range keys { + apl, err := rs.GetActionPlan(key[len(utils.ACTION_PLAN_PREFIX):], true, utils.NonTransactional) // skipCache on get since loader checks and caches empty data for loaded objects + if err != nil { + return err + } + for acntID := range apl.AccountIDs { + if err = rs.RemAccountActionPlans(acntID, []string{apl.Id}); err != nil { + return err + } + } + } + } + return nil +} + func (rs *RedisStorage) GetKeysForPrefix(prefix string) ([]string, error) { r := rs.Cmd("KEYS", prefix+"*") if r.Err != nil { @@ -256,6 +316,24 @@ func (rs *RedisStorage) SetRatingPlanDrv(rp *RatingPlan) (err error) { return } +func (rs *RedisStorage) RemoveRatingPlanDrv(key string) error { + keys, err := rs.Cmd("KEYS", utils.RATING_PLAN_PREFIX+key+"*").List() + if err != nil { + return err + } + for _, key := range keys { + if err = rs.Cmd("DEL", key).Err; err != nil { + return err + } + rpf := &RatingProfile{Id: key} + if historyScribe != nil { + response := 0 + go historyScribe.Call("HistoryV1.Record", rpf.GetHistoryRecord(true), &response) + } + } + return nil +} + func (rs *RedisStorage) GetRatingProfileDrv(key string) (rpf *RatingProfile, err error) { key = utils.RATING_PROFILE_PREFIX + key var values []byte @@ -332,6 +410,12 @@ func (rs *RedisStorage) SetLCRDrv(lcr *LCR) (err error) { return } +func (rs *RedisStorage) RemoveLCRDrv(id, transactionID string) (err error) { + dbKey := utils.LCR_PREFIX + id + err = rs.Cmd("DEL", dbKey).Err + return err +} + // GetDestination retrieves a destination with id from tp_db func (rs *RedisStorage) GetDestination(key string, skipCache bool, transactionID string) (dest *Destination, err error) { key = utils.DESTINATION_PREFIX + key @@ -548,6 +632,14 @@ func (rs *RedisStorage) SetSharedGroupDrv(sg *SharedGroup) (err error) { return } +func (rs *RedisStorage) RemoveSharedGroupDrv(id, transactionID string) (err error) { + cCommit := cacheCommit(transactionID) + dbKey := utils.SHARED_GROUP_PREFIX + id + err = rs.Cmd("DEL", dbKey).Err + cache.RemKey(dbKey, cCommit, transactionID) + return err +} + func (rs *RedisStorage) GetAccount(key string) (*Account, error) { rpl := rs.Cmd("GET", utils.ACCOUNT_PREFIX+key) if rpl.Err != nil { @@ -612,6 +704,12 @@ func (rs *RedisStorage) SetCdrStatsQueueDrv(sq *CDRStatsQueue) (err error) { return rs.Cmd("SET", utils.CDR_STATS_QUEUE_PREFIX+sq.GetId(), result).Err } +func (rs *RedisStorage) RemoveCdrStatsQueueDrv(id string) (err error) { + dbKey := utils.CDR_STATS_QUEUE_PREFIX + id + err = rs.Cmd("DEL", dbKey).Err + return err +} + func (rs *RedisStorage) GetSubscribersDrv() (result map[string]*SubscriberData, err error) { keys, err := rs.Cmd("KEYS", utils.PUBSUB_SUBSCRIBERS_PREFIX+"*").List() if err != nil { @@ -948,6 +1046,13 @@ func (rs *RedisStorage) GetActionPlan(key string, skipCache bool, transactionID cache.Set(key, ats, cacheCommit(transactionID), transactionID) return } +func (rs *RedisStorage) RemoveActionPlan(key string, transactionID string) error { + cCommit := cacheCommit(transactionID) + dbKey := utils.ACTION_PLAN_PREFIX + key + err := rs.Cmd("DEL", dbKey).Err + cache.RemKey(dbKey, cCommit, transactionID) + return err +} func (rs *RedisStorage) SetActionPlan(key string, ats *ActionPlan, overwrite bool, transactionID string) (err error) { cCommit := cacheCommit(transactionID) @@ -1121,6 +1226,16 @@ func (rs *RedisStorage) SetDerivedChargers(key string, dcs *utils.DerivedCharger return } +func (rs *RedisStorage) RemoveDerivedChargersDrv(id, transactionID string) (err error) { + cCommit := cacheCommit(transactionID) + key := utils.DERIVEDCHARGERS_PREFIX + id + if err = rs.Cmd("DEL", key).Err; err != nil { + return err + } + cache.RemKey(key, cCommit, transactionID) + return +} + func (rs *RedisStorage) SetCdrStatsDrv(cs *CdrStats) error { marshaled, err := rs.ms.Marshal(cs) if err != nil { @@ -1295,6 +1410,13 @@ func (rs *RedisStorage) SetReqFilterIndexesDrv(dbKey string, indexes map[string] return rs.Cmd("HMSET", dbKey, mp).Err } +func (rs *RedisStorage) RemoveReqFilterIndexesDrv(id string) (err error) { + if err = rs.Cmd("DEL", id).Err; err != nil { + return err + } + return +} + func (rs *RedisStorage) MatchReqFilterIndexDrv(dbKey, fldName, fldVal string) (itemIDs utils.StringMap, err error) { fieldValKey := utils.ConcatenatedKey(fldName, fldVal) // Not found in cache, check in DB diff --git a/engine/tp_reader.go b/engine/tp_reader.go index 816c412a4..2a3be4226 100755 --- a/engine/tp_reader.go +++ b/engine/tp_reader.go @@ -2653,3 +2653,351 @@ func (tpr *TpReader) GetLoadedIds(categ string) ([]string, error) { } return nil, errors.New("Unsupported load category") } + +func (tpr *TpReader) RemoveFromDatabase(verbose, disable_reverse bool) (err error) { + for _, d := range tpr.destinations { + err = tpr.dm.DataDB().RemoveDestination(d.Id, utils.NonTransactional) + if err != nil { + return err + } + if verbose { + log.Print("\t", d.Id, " : ", d.Prefixes) + } + } + if verbose { + log.Print("Reverse Destinations:") + for id, vals := range tpr.revDests { + log.Printf("\t %s : %+v", id, vals) + } + } + if verbose { + log.Print("Rating Plans:") + } + for _, rp := range tpr.ratingPlans { + err = tpr.dm.RemoveRatingPlan(rp.Id, utils.NonTransactional) + if err != nil { + return err + } + if verbose { + log.Print("\t", rp.Id) + } + } + if verbose { + log.Print("Rating Profiles:") + } + for _, rp := range tpr.ratingProfiles { + err = tpr.dm.RemoveRatingProfile(rp.Id, utils.NonTransactional) + if err != nil { + return err + } + if verbose { + log.Print("\t", rp.Id) + } + } + if verbose { + log.Print("Action Plans:") + } + for k, _ := range tpr.actionPlans { + err = tpr.dm.DataDB().RemoveActionPlan(k, utils.NonTransactional) + if err != nil { + return err + } + if verbose { + log.Println("\t", k) + } + } + if verbose { + log.Print("Account Action Plans:") + for id, vals := range tpr.acntActionPlans { + log.Printf("\t %s : %+v", id, vals) + } + } + if verbose { + log.Print("Action Triggers:") + } + for k, _ := range tpr.actionsTriggers { + err = tpr.dm.RemoveActionTriggers(k, utils.NonTransactional) + if err != nil { + return err + } + if verbose { + log.Println("\t", k) + } + } + if verbose { + log.Print("Shared Groups:") + } + for k, _ := range tpr.sharedGroups { + err = tpr.dm.RemoveSharedGroup(k, utils.NonTransactional) + if err != nil { + return err + } + if verbose { + log.Println("\t", k) + } + } + if verbose { + log.Print("LCR Rules:") + } + for k, lcr := range tpr.lcrs { + err = tpr.dm.RemoveLCR(lcr.GetId(), utils.NonTransactional) + if err != nil { + return err + } + if verbose { + log.Println("\t", k) + } + } + if verbose { + log.Print("Actions:") + } + for k, _ := range tpr.actions { + err = tpr.dm.RemoveActions(k, utils.NonTransactional) + if err != nil { + return err + } + if verbose { + log.Println("\t", k) + } + } + if verbose { + log.Print("Account Actions:") + } + for _, ub := range tpr.accountActions { + err = tpr.dm.DataDB().RemoveAccount(ub.ID) + if err != nil { + return err + } + if verbose { + log.Println("\t", ub.ID) + } + } + if verbose { + log.Print("Derived Chargers:") + } + for key, _ := range tpr.derivedChargers { + err = tpr.dm.RemoveDerivedChargers(key, utils.NonTransactional) + if err != nil { + return err + } + if verbose { + log.Print("\t", key) + } + } + if verbose { + log.Print("CDR Stats Queues:") + } + for _, sq := range tpr.cdrStats { + err = tpr.dm.RemoveCdrStatsQueue(sq.Id) + if err != nil { + return err + } + if verbose { + log.Print("\t", sq.Id) + } + } + if verbose { + log.Print("Users:") + } + for _, u := range tpr.users { + err = tpr.dm.RemoveUser(u.GetId()) + if err != nil { + return err + } + if verbose { + log.Print("\t", u.GetId()) + } + } + if verbose { + log.Print("Aliases:") + } + for _, al := range tpr.aliases { + err = tpr.dm.DataDB().RemoveAlias(al.GetId(), utils.NonTransactional) + if err != nil { + return err + } + if verbose { + log.Print("\t", al.GetId()) + } + } + if verbose { + log.Print("Reverse Aliases:") + for id, vals := range tpr.revAliases { + log.Printf("\t %s : %+v", id, vals) + } + } + if verbose { + log.Print("Filters:") + } + for _, tpTH := range tpr.filters { + if err = tpr.dm.RemoveFilter(tpTH.Tenant, tpTH.ID, utils.NonTransactional); err != nil { + return err + } + if verbose { + log.Print("\t", tpTH.Tenant) + } + } + if verbose { + log.Print("ResourceProfiles:") + } + for _, tpRsp := range tpr.resProfiles { + if err = tpr.dm.RemoveResourceProfile(tpRsp.Tenant, tpRsp.ID, utils.NonTransactional); err != nil { + return err + } + if verbose { + log.Print("\t", tpRsp.Tenant) + } + } + if verbose { + log.Print("Resources:") + } + for _, rTid := range tpr.resources { + if err = tpr.dm.RemoveResource(rTid.Tenant, rTid.ID, utils.NonTransactional); err != nil { + return + } + if verbose { + log.Print("\t", rTid.TenantID()) + } + } + if verbose { + log.Print("StatQueueProfiles:") + } + for _, tpST := range tpr.sqProfiles { + if err = tpr.dm.RemoveStatQueueProfile(tpST.Tenant, tpST.ID, utils.NonTransactional); err != nil { + return err + } + if verbose { + log.Print("\t", tpST.Tenant) + } + } + if verbose { + log.Print("StatQueues:") + } + for _, sqTntID := range tpr.statQueues { + if err = tpr.dm.RemStatQueue(sqTntID.Tenant, sqTntID.ID, utils.NonTransactional); err != nil { + return + } + if verbose { + log.Print("\t", sqTntID.Tenant) + } + } + if verbose { + log.Print("ThresholdProfiles:") + } + for _, tpTH := range tpr.thProfiles { + if err = tpr.dm.RemoveThresholdProfile(tpTH.Tenant, tpTH.ID, utils.NonTransactional); err != nil { + return err + } + if verbose { + log.Print("\t", tpTH.Tenant) + } + } + if verbose { + log.Print("Thresholds:") + } + for _, thd := range tpr.thresholds { + if err = tpr.dm.RemoveThreshold(thd.Tenant, thd.ID, utils.NonTransactional); err != nil { + return err + } + if verbose { + log.Print("\t", thd.Tenant) + } + } + + if verbose { + log.Print("SupplierProfiles:") + } + for _, tpTH := range tpr.sppProfiles { + if err = tpr.dm.RemoveSupplierProfile(tpTH.Tenant, tpTH.ID, utils.NonTransactional); err != nil { + return err + } + if verbose { + log.Print("\t", tpTH.Tenant) + } + } + if verbose { + log.Print("Timings:") + } + for _, t := range tpr.timings { + if err = tpr.dm.RemoveTiming(t.ID, utils.NonTransactional); err != nil { + return err + } + if verbose { + log.Print("\t", t.ID) + } + } + if !disable_reverse { + if len(tpr.destinations) > 0 { + if verbose { + log.Print("Removing reverse destinations") + } + if err = tpr.dm.DataDB().RemoveReverseForPrefix(utils.REVERSE_DESTINATION_PREFIX); err != nil { + return err + } + } + if len(tpr.acntActionPlans) > 0 { + if verbose { + log.Print("Removing account action plans") + } + if err = tpr.dm.DataDB().RemoveReverseForPrefix(utils.AccountActionPlansPrefix); err != nil { + return err + } + } + if len(tpr.aliases) > 0 { + if verbose { + log.Print("Removing reverse aliases") + } + if err = tpr.dm.DataDB().RemoveReverseForPrefix(utils.REVERSE_ALIASES_PREFIX); err != nil { + return err + } + } + if verbose { + log.Print("Indexing resource profiles") + } + for tenant, fltrIdxer := range tpr.resIndexers { + if err := tpr.dm.RemoveReqFilterIndexes(GetDBIndexKey(fltrIdxer.itemType, fltrIdxer.dbKeySuffix, false)); err != nil { + return err + } + if verbose { + log.Printf("Tenant: %s, keys %+v", tenant, fltrIdxer.ChangedKeys(false).Slice()) + } + } + + if verbose { + log.Print("StatQueue filter indexes:") + } + for tenant, fltrIdxer := range tpr.sqpIndexers { + if err := tpr.dm.RemoveReqFilterIndexes(GetDBIndexKey(fltrIdxer.itemType, fltrIdxer.dbKeySuffix, false)); err != nil { + return err + } + if verbose { + log.Printf("Tenant: %s, keys %+v", tenant, fltrIdxer.ChangedKeys(true).Slice()) + } + } + + if verbose { + log.Print("Threshold filter indexes:") + } + for tenant, fltrIdxer := range tpr.thdsIndexers { + if err := tpr.dm.RemoveReqFilterIndexes(GetDBIndexKey(fltrIdxer.itemType, fltrIdxer.dbKeySuffix, false)); err != nil { + return err + } + if verbose { + log.Printf("Tenant: %s, keys %+v", tenant, fltrIdxer.ChangedKeys(false).Slice()) + } + } + + if verbose { + log.Print("Indexing Supplier Profiles") + } + for tenant, fltrIdxer := range tpr.sppIndexers { + if err := tpr.dm.RemoveReqFilterIndexes(GetDBIndexKey(fltrIdxer.itemType, fltrIdxer.dbKeySuffix, false)); err != nil { + return err + } + if verbose { + log.Printf("Tenant: %s, keys %+v", tenant, fltrIdxer.ChangedKeys(true).Slice()) + } + } + } + return +}