more duplicate code removal

engine/loader_csv.go

@@ -89,235 +89,15 @@ func openStringCSVReader(data string, comma rune, nrFields int) (csvReader *csv.
 }
 
 func (csvr *CSVReader) ShowStatistics() {
-	// destinations
-	destCount := len(csvr.tp.destinations)
-	log.Print("Destinations: ", destCount)
-	prefixDist := make(map[int]int, 50)
-	prefixCount := 0
-	for _, d := range csvr.tp.destinations {
-		prefixDist[len(d.Prefixes)] += 1
-		prefixCount += len(d.Prefixes)
-	}
-	log.Print("Avg Prefixes: ", prefixCount/destCount)
-	log.Print("Prefixes distribution:")
-	for k, v := range prefixDist {
-		log.Printf("%d: %d", k, v)
-	}
-	// rating plans
-	rplCount := len(csvr.tp.ratingPlans)
-	log.Print("Rating plans: ", rplCount)
-	destRatesDist := make(map[int]int, 50)
-	destRatesCount := 0
-	for _, rpl := range csvr.tp.ratingPlans {
-		destRatesDist[len(rpl.DestinationRates)] += 1
-		destRatesCount += len(rpl.DestinationRates)
-	}
-	log.Print("Avg Destination Rates: ", destRatesCount/rplCount)
-	log.Print("Destination Rates distribution:")
-	for k, v := range destRatesDist {
-		log.Printf("%d: %d", k, v)
-	}
-	// rating profiles
-	rpfCount := len(csvr.tp.ratingProfiles)
-	log.Print("Rating profiles: ", rpfCount)
-	activDist := make(map[int]int, 50)
-	activCount := 0
-	for _, rpf := range csvr.tp.ratingProfiles {
-		activDist[len(rpf.RatingPlanActivations)] += 1
-		activCount += len(rpf.RatingPlanActivations)
-	}
-	log.Print("Avg Activations: ", activCount/rpfCount)
-	log.Print("Activation distribution:")
-	for k, v := range activDist {
-		log.Printf("%d: %d", k, v)
-	}
-	// actions
-	log.Print("Actions: ", len(csvr.tp.actions))
-	// action plans
-	log.Print("Action plans: ", len(csvr.tp.actionsTimings))
-	// action trigers
-	log.Print("Action trigers: ", len(csvr.tp.actionsTriggers))
-	// account actions
-	log.Print("Account actions: ", len(csvr.tp.accountActions))
-	// derivedChargers
-	log.Print("Derived Chargers: ", len(csvr.tp.derivedChargers))
-	// lcr rules
-	log.Print("LCR rules: ", len(csvr.tp.lcrs))
-	// cdr stats
-	log.Print("CDR stats: ", len(csvr.tp.cdrStats))
+	csvr.tp.ShowStatistics()
 }
 
 func (csvr *CSVReader) IsDataValid() bool {
-	valid := true
-	for rplTag, rpl := range csvr.tp.ratingPlans {
-		if !rpl.IsValid() {
-			log.Printf("The rating plan %s is not covering all weekdays", rplTag)
-			valid = false
-		}
-	}
-	return valid
+	return csvr.tp.IsValid()
 }
 
 func (csvr *CSVReader) WriteToDatabase(flush, verbose bool) (err error) {
-	dataStorage := csvr.dataStorage
-	accountingStorage := csvr.accountingStorage
-	if dataStorage == nil {
-		return errors.New("No database connection!")
-	}
-	if flush {
-		dataStorage.Flush("")
-	}
-	if verbose {
-		log.Print("Destinations:")
-	}
-	for _, d := range csvr.tp.destinations {
-		err = dataStorage.SetDestination(d)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Print("\t", d.Id, " : ", d.Prefixes)
-		}
-	}
-	if verbose {
-		log.Print("Rating Plans:")
-	}
-	for _, rp := range csvr.tp.ratingPlans {
-		err = dataStorage.SetRatingPlan(rp)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Print("\t", rp.Id)
-		}
-	}
-	if verbose {
-		log.Print("Rating Profiles:")
-	}
-	for _, rp := range csvr.tp.ratingProfiles {
-		err = dataStorage.SetRatingProfile(rp)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Print("\t", rp.Id)
-		}
-	}
-	if verbose {
-		log.Print("Action Plans:")
-	}
-	for k, ats := range csvr.tp.actionsTimings {
-		err = accountingStorage.SetActionTimings(k, ats)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Println("\t", k)
-		}
-	}
-	if verbose {
-		log.Print("Shared Groups:")
-	}
-	for k, sg := range csvr.tp.sharedGroups {
-		err = accountingStorage.SetSharedGroup(sg)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Println("\t", k)
-		}
-	}
-	if verbose {
-		log.Print("LCR Rules:")
-	}
-	for k, lcr := range csvr.tp.lcrs {
-		err = dataStorage.SetLCR(lcr)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Println("\t", k)
-		}
-	}
-	if verbose {
-		log.Print("Actions:")
-	}
-	for k, as := range csvr.tp.actions {
-		err = accountingStorage.SetActions(k, as)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Println("\t", k)
-		}
-	}
-	if verbose {
-		log.Print("Account Actions:")
-	}
-	for _, ub := range csvr.tp.accountActions {
-		err = accountingStorage.SetAccount(ub)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Println("\t", ub.Id)
-		}
-	}
-	if verbose {
-		log.Print("Rating Profile Aliases:")
-	}
-	if err := dataStorage.RemoveRpAliases(csvr.tp.dirtyRpAliases); err != nil {
-		return err
-	}
-	for key, alias := range csvr.tp.rpAliases {
-		err = dataStorage.SetRpAlias(key, alias)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Print("\t", key)
-		}
-	}
-	if verbose {
-		log.Print("Account Aliases:")
-	}
-	if err := accountingStorage.RemoveAccAliases(csvr.tp.dirtyAccAliases); err != nil {
-		return err
-	}
-	for key, alias := range csvr.tp.accAliases {
-		err = accountingStorage.SetAccAlias(key, alias)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Print("\t", key)
-		}
-	}
-	if verbose {
-		log.Print("Derived Chargers:")
-	}
-	for key, dcs := range csvr.tp.derivedChargers {
-		err = accountingStorage.SetDerivedChargers(key, dcs)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Print("\t", key)
-		}
-	}
-	if verbose {
-		log.Print("CDR Stats Queues:")
-	}
-	for _, sq := range csvr.tp.cdrStats {
-		err = dataStorage.SetCdrStats(sq)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Print("\t", sq.Id)
-		}
-	}
-	return
+	return csvr.tp.WriteToDatabase(csvr.dataStorage, csvr.accountingStorage, flush, verbose)
 }
 
 func (csvr *CSVReader) LoadDestinations() (err error) {
@@ -1046,87 +826,5 @@ func (csvr *CSVReader) LoadAll() error {
 
 // Returns the identities loaded for a specific category, useful for cache reloads
 func (csvr *CSVReader) GetLoadedIds(categ string) ([]string, error) {
-	switch categ {
-	case DESTINATION_PREFIX:
-		keys := make([]string, len(csvr.tp.destinations))
-		i := 0
-		for k := range csvr.tp.destinations {
-			keys[i] = k
-			i++
-		}
-		return keys, nil
-	case RATING_PLAN_PREFIX:
-		keys := make([]string, len(csvr.tp.ratingPlans))
-		i := 0
-		for k := range csvr.tp.ratingPlans {
-			keys[i] = k
-			i++
-		}
-		return keys, nil
-	case RATING_PROFILE_PREFIX:
-		keys := make([]string, len(csvr.tp.ratingProfiles))
-		i := 0
-		for k := range csvr.tp.ratingProfiles {
-			keys[i] = k
-			i++
-		}
-		return keys, nil
-	case ACTION_PREFIX: // actionsTimings
-		keys := make([]string, len(csvr.tp.actions))
-		i := 0
-		for k := range csvr.tp.actions {
-			keys[i] = k
-			i++
-		}
-		return keys, nil
-	case ACTION_TIMING_PREFIX: // actionsTimings
-		keys := make([]string, len(csvr.tp.actionsTimings))
-		i := 0
-		for k := range csvr.tp.actionsTimings {
-			keys[i] = k
-			i++
-		}
-		return keys, nil
-	case RP_ALIAS_PREFIX: // aliases
-		keys := make([]string, len(csvr.tp.rpAliases))
-		i := 0
-		for k := range csvr.tp.rpAliases {
-			keys[i] = k
-			i++
-		}
-		return keys, nil
-	case ACC_ALIAS_PREFIX: // aliases
-		keys := make([]string, len(csvr.tp.accAliases))
-		i := 0
-		for k := range csvr.tp.accAliases {
-			keys[i] = k
-			i++
-		}
-		return keys, nil
-	case DERIVEDCHARGERS_PREFIX: // derived chargers
-		keys := make([]string, len(csvr.tp.derivedChargers))
-		i := 0
-		for k := range csvr.tp.derivedChargers {
-			keys[i] = k
-			i++
-		}
-		return keys, nil
-	case CDR_STATS_PREFIX: // cdr stats
-		keys := make([]string, len(csvr.tp.cdrStats))
-		i := 0
-		for k := range csvr.tp.cdrStats {
-			keys[i] = k
-			i++
-		}
-		return keys, nil
-	case SHARED_GROUP_PREFIX:
-		keys := make([]string, len(csvr.tp.sharedGroups))
-		i := 0
-		for k := range csvr.tp.sharedGroups {
-			keys[i] = k
-			i++
-		}
-		return keys, nil
-	}
-	return nil, errors.New("Unsupported category")
+	return csvr.tp.GetLoadedIds(categ)
 }

engine/loader_db.go

@@ -48,227 +48,15 @@ func NewDbReader(storDB LoadStorage, ratingDb RatingStorage, accountDb Accountin
 
 // FIXME: this method is code duplication from csv loader
 func (dbr *DbReader) ShowStatistics() {
-	// destinations
-	destCount := len(dbr.tp.destinations)
-	log.Print("Destinations: ", destCount)
-	prefixDist := make(map[int]int, 50)
-	prefixCount := 0
-	for _, d := range dbr.tp.destinations {
-		prefixDist[len(d.Prefixes)] += 1
-		prefixCount += len(d.Prefixes)
-	}
-	log.Print("Avg Prefixes: ", prefixCount/destCount)
-	log.Print("Prefixes distribution:")
-	for k, v := range prefixDist {
-		log.Printf("%d: %d", k, v)
-	}
-	// rating plans
-	rplCount := len(dbr.tp.ratingPlans)
-	log.Print("Rating plans: ", rplCount)
-	destRatesDist := make(map[int]int, 50)
-	destRatesCount := 0
-	for _, rpl := range dbr.tp.ratingPlans {
-		destRatesDist[len(rpl.DestinationRates)] += 1
-		destRatesCount += len(rpl.DestinationRates)
-	}
-	log.Print("Avg Destination Rates: ", destRatesCount/rplCount)
-	log.Print("Destination Rates distribution:")
-	for k, v := range destRatesDist {
-		log.Printf("%d: %d", k, v)
-	}
-	// rating profiles
-	rpfCount := len(dbr.tp.ratingProfiles)
-	log.Print("Rating profiles: ", rpfCount)
-	activDist := make(map[int]int, 50)
-	activCount := 0
-	for _, rpf := range dbr.tp.ratingProfiles {
-		activDist[len(rpf.RatingPlanActivations)] += 1
-		activCount += len(rpf.RatingPlanActivations)
-	}
-	log.Print("Avg Activations: ", activCount/rpfCount)
-	log.Print("Activation distribution:")
-	for k, v := range activDist {
-		log.Printf("%d: %d", k, v)
-	}
-	// actions
-	log.Print("Actions: ", len(dbr.tp.actions))
-	// action timings
-	log.Print("Action plans: ", len(dbr.tp.actionsTimings))
-	// account actions
-	log.Print("Account actions: ", len(dbr.tp.accountActions))
-	// derivedChargers
-	log.Print("Derived Chargers: ", len(dbr.tp.derivedChargers))
-	// lcr rules
-	log.Print("LCR rules: ", len(dbr.tp.lcrs))
+	dbr.tp.ShowStatistics()
 }
 
 func (dbr *DbReader) IsDataValid() bool {
-	valid := true
-	for rplTag, rpl := range dbr.tp.ratingPlans {
-		if !rpl.IsValid() {
-			log.Printf("The rating plan %s is not covering all weekdays", rplTag)
-			valid = false
-		}
-	}
-	return valid
+	return dbr.tp.IsValid()
 }
 
 func (dbr *DbReader) WriteToDatabase(flush, verbose bool) (err error) {
-	storage := dbr.dataDb
-	if flush {
-		storage.Flush("")
-	}
-	if verbose {
-		log.Print("Destinations")
-	}
-	for _, d := range dbr.tp.destinations {
-		err = storage.SetDestination(d)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Print(d.Id, " : ", d.Prefixes)
-		}
-	}
-	if verbose {
-		log.Print("Rating plans")
-	}
-	for _, rp := range dbr.tp.ratingPlans {
-		err = storage.SetRatingPlan(rp)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Print(rp.Id)
-		}
-	}
-	if verbose {
-		log.Print("Rating profiles")
-	}
-	for _, rp := range dbr.tp.ratingProfiles {
-		err = storage.SetRatingProfile(rp)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Print(rp.Id)
-		}
-	}
-	if verbose {
-		log.Print("Action plans")
-	}
-	for k, ats := range dbr.tp.actionsTimings {
-		err = accountingStorage.SetActionTimings(k, ats)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Println(k)
-		}
-	}
-	if verbose {
-		log.Print("Shared groups")
-	}
-	for k, sg := range dbr.tp.sharedGroups {
-		err = accountingStorage.SetSharedGroup(sg)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Println(k)
-		}
-	}
-	if verbose {
-		log.Print("LCR Rules")
-	}
-	for k, lcr := range dbr.tp.lcrs {
-		err = dataStorage.SetLCR(lcr)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Println(k)
-		}
-	}
-	if verbose {
-		log.Print("Actions")
-	}
-	for k, as := range dbr.tp.actions {
-		err = accountingStorage.SetActions(k, as)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Println(k)
-		}
-	}
-	if verbose {
-		log.Print("Account actions")
-	}
-	for _, ub := range dbr.tp.accountActions {
-		err = accountingStorage.SetAccount(ub)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Println(ub.Id)
-		}
-	}
-	if verbose {
-		log.Print("Rating profile aliases")
-	}
-	if err := storage.RemoveRpAliases(dbr.tp.dirtyRpAliases); err != nil {
-		return err
-	}
-	for key, alias := range dbr.tp.rpAliases {
-		err = storage.SetRpAlias(key, alias)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Println(key)
-		}
-	}
-	if verbose {
-		log.Print("Account aliases")
-	}
-	if err := accountingStorage.RemoveAccAliases(dbr.tp.dirtyAccAliases); err != nil {
-		return err
-	}
-	for key, alias := range dbr.tp.accAliases {
-		err = accountingStorage.SetAccAlias(key, alias)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Println(key)
-		}
-	}
-	if verbose {
-		log.Print("Derived Chargers")
-	}
-	for key, dcs := range dbr.tp.derivedChargers {
-		err = accountingStorage.SetDerivedChargers(key, dcs)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Print(key)
-		}
-	}
-	if verbose {
-		log.Print("CDR Stats Queues")
-	}
-	for _, sq := range dbr.tp.cdrStats {
-		err = dataStorage.SetCdrStats(sq)
-		if err != nil {
-			return err
-		}
-		if verbose {
-			log.Print(sq.Id)
-		}
-	}
-	return
+	return dbr.tp.WriteToDatabase(dbr.dataDb, dbr.accountDb, flush, verbose)
 }
 
 func (dbr *DbReader) LoadDestinations() (err error) {
@@ -993,87 +781,5 @@ func (dbr *DbReader) LoadAll() error {
 
 // Returns the identities loaded for a specific entity category
 func (dbr *DbReader) GetLoadedIds(categ string) ([]string, error) {
-	switch categ {
-	case DESTINATION_PREFIX:
-		ids := make([]string, len(dbr.tp.destinations))
-		i := 0
-		for k := range dbr.tp.destinations {
-			ids[i] = k
-			i++
-		}
-		return ids, nil
-	case RATING_PLAN_PREFIX:
-		keys := make([]string, len(dbr.tp.ratingPlans))
-		i := 0
-		for k := range dbr.tp.ratingPlans {
-			keys[i] = k
-			i++
-		}
-		return keys, nil
-	case RATING_PROFILE_PREFIX:
-		keys := make([]string, len(dbr.tp.ratingProfiles))
-		i := 0
-		for k := range dbr.tp.ratingProfiles {
-			keys[i] = k
-			i++
-		}
-		return keys, nil
-	case ACTION_PREFIX: // actions
-		keys := make([]string, len(dbr.tp.actions))
-		i := 0
-		for k := range dbr.tp.actions {
-			keys[i] = k
-			i++
-		}
-		return keys, nil
-	case ACTION_TIMING_PREFIX: // actionsTimings
-		keys := make([]string, len(dbr.tp.actionsTimings))
-		i := 0
-		for k := range dbr.tp.actionsTimings {
-			keys[i] = k
-			i++
-		}
-		return keys, nil
-	case RP_ALIAS_PREFIX: // aliases
-		keys := make([]string, len(dbr.tp.rpAliases))
-		i := 0
-		for k := range dbr.tp.rpAliases {
-			keys[i] = k
-			i++
-		}
-		return keys, nil
-	case ACC_ALIAS_PREFIX: // aliases
-		keys := make([]string, len(dbr.tp.accAliases))
-		i := 0
-		for k := range dbr.tp.accAliases {
-			keys[i] = k
-			i++
-		}
-		return keys, nil
-	case DERIVEDCHARGERS_PREFIX: // derived charges
-		keys := make([]string, len(dbr.tp.derivedChargers))
-		i := 0
-		for k := range dbr.tp.derivedChargers {
-			keys[i] = k
-			i++
-		}
-		return keys, nil
-	case SHARED_GROUP_PREFIX:
-		keys := make([]string, len(dbr.tp.sharedGroups))
-		i := 0
-		for k := range dbr.tp.sharedGroups {
-			keys[i] = k
-			i++
-		}
-		return keys, nil
-	case CDR_STATS_PREFIX: // cdr stats
-		keys := make([]string, len(dbr.tp.cdrStats))
-		i := 0
-		for k := range dbr.tp.cdrStats {
-			keys[i] = k
-			i++
-		}
-		return keys, nil
-	}
-	return nil, errors.New("Unsupported category")
+	return dbr.tp.GetLoadedIds(categ)
 }

engine/loader_helpers.go

@@ -167,6 +167,323 @@ func NewTPData() *TPData {
 	return tp
 }
 
+func (tp *TPData) IsValid() bool {
+	valid := true
+	for rplTag, rpl := range tp.ratingPlans {
+		if !rpl.IsValid() {
+			log.Printf("The rating plan %s is not covering all weekdays", rplTag)
+			valid = false
+		}
+	}
+	return valid
+}
+
+func (tp *TPData) WriteToDatabase(dataStorage RatingStorage, accountingStorage AccountingStorage, flush, verbose bool) (err error) {
+	if dataStorage == nil {
+		return errors.New("No database connection!")
+	}
+	if flush {
+		dataStorage.Flush("")
+	}
+	if verbose {
+		log.Print("Destinations:")
+	}
+	for _, d := range tp.destinations {
+		err = dataStorage.SetDestination(d)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", d.Id, " : ", d.Prefixes)
+		}
+	}
+	if verbose {
+		log.Print("Rating Plans:")
+	}
+	for _, rp := range tp.ratingPlans {
+		err = dataStorage.SetRatingPlan(rp)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", rp.Id)
+		}
+	}
+	if verbose {
+		log.Print("Rating Profiles:")
+	}
+	for _, rp := range tp.ratingProfiles {
+		err = dataStorage.SetRatingProfile(rp)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", rp.Id)
+		}
+	}
+	if verbose {
+		log.Print("Action Plans:")
+	}
+	for k, ats := range tp.actionsTimings {
+		err = accountingStorage.SetActionTimings(k, ats)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Println("\t", k)
+		}
+	}
+	if verbose {
+		log.Print("Shared Groups:")
+	}
+	for k, sg := range tp.sharedGroups {
+		err = accountingStorage.SetSharedGroup(sg)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Println("\t", k)
+		}
+	}
+	if verbose {
+		log.Print("LCR Rules:")
+	}
+	for k, lcr := range tp.lcrs {
+		err = dataStorage.SetLCR(lcr)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Println("\t", k)
+		}
+	}
+	if verbose {
+		log.Print("Actions:")
+	}
+	for k, as := range tp.actions {
+		err = accountingStorage.SetActions(k, as)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Println("\t", k)
+		}
+	}
+	if verbose {
+		log.Print("Account Actions:")
+	}
+	for _, ub := range tp.accountActions {
+		err = accountingStorage.SetAccount(ub)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Println("\t", ub.Id)
+		}
+	}
+	if verbose {
+		log.Print("Rating Profile Aliases:")
+	}
+	if err := dataStorage.RemoveRpAliases(tp.dirtyRpAliases); err != nil {
+		return err
+	}
+	for key, alias := range tp.rpAliases {
+		err = dataStorage.SetRpAlias(key, alias)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", key)
+		}
+	}
+	if verbose {
+		log.Print("Account Aliases:")
+	}
+	if err := accountingStorage.RemoveAccAliases(tp.dirtyAccAliases); err != nil {
+		return err
+	}
+	for key, alias := range tp.accAliases {
+		err = accountingStorage.SetAccAlias(key, alias)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", key)
+		}
+	}
+	if verbose {
+		log.Print("Derived Chargers:")
+	}
+	for key, dcs := range tp.derivedChargers {
+		err = accountingStorage.SetDerivedChargers(key, dcs)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", key)
+		}
+	}
+	if verbose {
+		log.Print("CDR Stats Queues:")
+	}
+	for _, sq := range tp.cdrStats {
+		err = dataStorage.SetCdrStats(sq)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", sq.Id)
+		}
+	}
+	return
+}
+
+func (tp *TPData) ShowStatistics() {
+	// destinations
+	destCount := len(tp.destinations)
+	log.Print("Destinations: ", destCount)
+	prefixDist := make(map[int]int, 50)
+	prefixCount := 0
+	for _, d := range tp.destinations {
+		prefixDist[len(d.Prefixes)] += 1
+		prefixCount += len(d.Prefixes)
+	}
+	log.Print("Avg Prefixes: ", prefixCount/destCount)
+	log.Print("Prefixes distribution:")
+	for k, v := range prefixDist {
+		log.Printf("%d: %d", k, v)
+	}
+	// rating plans
+	rplCount := len(tp.ratingPlans)
+	log.Print("Rating plans: ", rplCount)
+	destRatesDist := make(map[int]int, 50)
+	destRatesCount := 0
+	for _, rpl := range tp.ratingPlans {
+		destRatesDist[len(rpl.DestinationRates)] += 1
+		destRatesCount += len(rpl.DestinationRates)
+	}
+	log.Print("Avg Destination Rates: ", destRatesCount/rplCount)
+	log.Print("Destination Rates distribution:")
+	for k, v := range destRatesDist {
+		log.Printf("%d: %d", k, v)
+	}
+	// rating profiles
+	rpfCount := len(tp.ratingProfiles)
+	log.Print("Rating profiles: ", rpfCount)
+	activDist := make(map[int]int, 50)
+	activCount := 0
+	for _, rpf := range tp.ratingProfiles {
+		activDist[len(rpf.RatingPlanActivations)] += 1
+		activCount += len(rpf.RatingPlanActivations)
+	}
+	log.Print("Avg Activations: ", activCount/rpfCount)
+	log.Print("Activation distribution:")
+	for k, v := range activDist {
+		log.Printf("%d: %d", k, v)
+	}
+	// actions
+	log.Print("Actions: ", len(tp.actions))
+	// action plans
+	log.Print("Action plans: ", len(tp.actionsTimings))
+	// action trigers
+	log.Print("Action trigers: ", len(tp.actionsTriggers))
+	// account actions
+	log.Print("Account actions: ", len(tp.accountActions))
+	// derivedChargers
+	log.Print("Derived Chargers: ", len(tp.derivedChargers))
+	// lcr rules
+	log.Print("LCR rules: ", len(tp.lcrs))
+	// cdr stats
+	log.Print("CDR stats: ", len(tp.cdrStats))
+}
+
+// Returns the identities loaded for a specific category, useful for cache reloads
+func (tp *TPData) GetLoadedIds(categ string) ([]string, error) {
+	switch categ {
+	case DESTINATION_PREFIX:
+		keys := make([]string, len(tp.destinations))
+		i := 0
+		for k := range tp.destinations {
+			keys[i] = k
+			i++
+		}
+		return keys, nil
+	case RATING_PLAN_PREFIX:
+		keys := make([]string, len(tp.ratingPlans))
+		i := 0
+		for k := range tp.ratingPlans {
+			keys[i] = k
+			i++
+		}
+		return keys, nil
+	case RATING_PROFILE_PREFIX:
+		keys := make([]string, len(tp.ratingProfiles))
+		i := 0
+		for k := range tp.ratingProfiles {
+			keys[i] = k
+			i++
+		}
+		return keys, nil
+	case ACTION_PREFIX: // actionsTimings
+		keys := make([]string, len(tp.actions))
+		i := 0
+		for k := range tp.actions {
+			keys[i] = k
+			i++
+		}
+		return keys, nil
+	case ACTION_TIMING_PREFIX: // actionsTimings
+		keys := make([]string, len(tp.actionsTimings))
+		i := 0
+		for k := range tp.actionsTimings {
+			keys[i] = k
+			i++
+		}
+		return keys, nil
+	case RP_ALIAS_PREFIX: // aliases
+		keys := make([]string, len(tp.rpAliases))
+		i := 0
+		for k := range tp.rpAliases {
+			keys[i] = k
+			i++
+		}
+		return keys, nil
+	case ACC_ALIAS_PREFIX: // aliases
+		keys := make([]string, len(tp.accAliases))
+		i := 0
+		for k := range tp.accAliases {
+			keys[i] = k
+			i++
+		}
+		return keys, nil
+	case DERIVEDCHARGERS_PREFIX: // derived chargers
+		keys := make([]string, len(tp.derivedChargers))
+		i := 0
+		for k := range tp.derivedChargers {
+			keys[i] = k
+			i++
+		}
+		return keys, nil
+	case CDR_STATS_PREFIX: // cdr stats
+		keys := make([]string, len(tp.cdrStats))
+		i := 0
+		for k := range tp.cdrStats {
+			keys[i] = k
+			i++
+		}
+		return keys, nil
+	case SHARED_GROUP_PREFIX:
+		keys := make([]string, len(tp.sharedGroups))
+		i := 0
+		for k := range tp.sharedGroups {
+			keys[i] = k
+			i++
+		}
+		return keys, nil
+	}
+	return nil, errors.New("Unsupported category")
+}
+
 func NewLoadRate(tag, connectFee, price, ratedUnits, rateIncrements, groupInterval string) (r *utils.TPRate, err error) {
 	cf, err := strconv.ParseFloat(connectFee, 64)
 	if err != nil {