func (ms *MapStorage) CacheRating(dKeys, rpKeys, rpfKeys, alsKeys, lcrKeys []string) error {
cache2go.BeginTransaction()
if dKeys == nil {
cache2go.RemPrefixKey(DESTINATION_PREFIX)
} else {
CleanStalePrefixes(dKeys)
}
if rpKeys == nil {
cache2go.RemPrefixKey(RATING_PLAN_PREFIX)
}
if rpfKeys == nil {
cache2go.RemPrefixKey(RATING_PROFILE_PREFIX)
}
if alsKeys == nil {
cache2go.RemPrefixKey(RP_ALIAS_PREFIX)
}
if lcrKeys == nil {
cache2go.RemPrefixKey(LCR_PREFIX)
}
for k, _ := range ms.dict {
if strings.HasPrefix(k, DESTINATION_PREFIX) {
if _, err := ms.GetDestination(k[len(DESTINATION_PREFIX):]); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if strings.HasPrefix(k, RATING_PLAN_PREFIX) {
cache2go.RemKey(k)
if _, err := ms.GetRatingPlan(k[len(RATING_PLAN_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if strings.HasPrefix(k, RATING_PROFILE_PREFIX) {
cache2go.RemKey(k)
if _, err := ms.GetRatingProfile(k[len(RATING_PROFILE_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if strings.HasPrefix(k, RP_ALIAS_PREFIX) {
cache2go.RemKey(k)
if _, err := ms.GetRpAlias(k[len(RP_ALIAS_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if strings.HasPrefix(k, LCR_PREFIX) {
cache2go.RemKey(k)
if _, err := ms.GetLCR(k[len(LCR_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
}
cache2go.CommitTransaction()
return nil
}
func (rs *RedisStorage) cacheAccounting(alsKeys []string) (err error) {
cache2go.BeginTransaction()
if alsKeys == nil {
cache2go.RemPrefixKey(utils.ALIASES_PREFIX)
}
if alsKeys == nil {
utils.Logger.Info("Caching all aliases")
if alsKeys, err = rs.db.Keys(utils.ALIASES_PREFIX + "*"); err != nil {
cache2go.RollbackTransaction()
return err
}
} else if len(alsKeys) != 0 {
utils.Logger.Info(fmt.Sprintf("Caching aliases: %v", alsKeys))
}
for _, key := range alsKeys {
cache2go.RemKey(key)
if _, err = rs.GetAlias(key[len(utils.ALIASES_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(alsKeys) != 0 {
utils.Logger.Info("Finished aliases caching.")
}
utils.Logger.Info("Caching load history")
if _, err = rs.GetLoadHistory(1, true); err != nil {
cache2go.RollbackTransaction()
return err
}
utils.Logger.Info("Finished load history caching.")
cache2go.CommitTransaction()
return nil
}
func (rs *RedisStorage) PreloadCacheForPrefix(prefix string) error {
transID := cache2go.BeginTransaction()
cache2go.RemPrefixKey(prefix, false, transID)
keyList, err := rs.GetKeysForPrefix(prefix)
if err != nil {
cache2go.RollbackTransaction(transID)
return err
}
switch prefix {
case utils.RATING_PLAN_PREFIX:
for _, key := range keyList {
_, err := rs.GetRatingPlan(key[len(utils.RATING_PLAN_PREFIX):], true, transID)
if err != nil {
cache2go.RollbackTransaction(transID)
return err
}
}
case utils.ResourceLimitsPrefix:
for _, key := range keyList {
_, err = rs.GetResourceLimit(key[len(utils.ResourceLimitsPrefix):], true, transID)
if err != nil {
cache2go.RollbackTransaction(transID)
return err
}
}
default:
return utils.ErrInvalidKey
}
cache2go.CommitTransaction(transID)
return nil
}
func (ms *MapStorage) CacheAccounting(actKeys, shgKeys, alsKeys, dcsKeys []string) error {
cache2go.BeginTransaction()
if actKeys == nil {
cache2go.RemPrefixKey(ACTION_PREFIX) // Forced until we can fine tune it
}
if shgKeys == nil {
cache2go.RemPrefixKey(SHARED_GROUP_PREFIX) // Forced until we can fine tune it
}
if alsKeys == nil {
cache2go.RemPrefixKey(ACC_ALIAS_PREFIX)
}
if dcsKeys == nil {
cache2go.RemPrefixKey(DERIVEDCHARGERS_PREFIX)
}
for k, _ := range ms.dict {
if strings.HasPrefix(k, ACTION_PREFIX) {
cache2go.RemKey(k)
if _, err := ms.GetActions(k[len(ACTION_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if strings.HasPrefix(k, SHARED_GROUP_PREFIX) {
cache2go.RemKey(k)
if _, err := ms.GetSharedGroup(k[len(SHARED_GROUP_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if strings.HasPrefix(k, ACC_ALIAS_PREFIX) {
cache2go.RemKey(k)
if _, err := ms.GetAccAlias(k[len(ACC_ALIAS_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if strings.HasPrefix(k, DERIVEDCHARGERS_PREFIX) {
cache2go.RemKey(k)
if _, err := ms.GetDerivedChargers(k[len(DERIVEDCHARGERS_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
}
cache2go.CommitTransaction()
return nil
}
func (rs *RedisStorage) cacheAccounting(alsKeys []string) (err error) {
cache2go.BeginTransaction()
conn, err := rs.db.Get()
if err != nil {
return err
}
defer rs.db.Put(conn)
if alsKeys == nil {
utils.Logger.Info("Caching all aliases")
if alsKeys, err = conn.Cmd("KEYS", utils.ALIASES_PREFIX+"*").List(); err != nil {
cache2go.RollbackTransaction()
return err
}
cache2go.RemPrefixKey(utils.ALIASES_PREFIX)
cache2go.RemPrefixKey(utils.REVERSE_ALIASES_PREFIX)
} else if len(alsKeys) != 0 {
utils.Logger.Info(fmt.Sprintf("Caching aliases: %v", alsKeys))
}
al := &Alias{}
for _, key := range alsKeys {
// check if it already exists
// to remove reverse cache keys
if avs, err := cache2go.Get(key); err == nil && avs != nil {
al.Values = avs.(AliasValues)
al.SetId(key[len(utils.ALIASES_PREFIX):])
al.RemoveReverseCache()
}
cache2go.RemKey(key)
if _, err = rs.GetAlias(key[len(utils.ALIASES_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(alsKeys) != 0 {
utils.Logger.Info("Finished aliases caching.")
}
utils.Logger.Info("Caching load history")
if _, err = rs.GetLoadHistory(1, true); err != nil {
cache2go.RollbackTransaction()
return err
}
utils.Logger.Info("Finished load history caching.")
cache2go.CommitTransaction()
return nil
}
func (ms *MapStorage) cacheAccounting(alsKeys []string) error {
cache2go.BeginTransaction()
if alsKeys == nil {
cache2go.RemPrefixKey(utils.ALIASES_PREFIX) // Forced until we can fine tune it
}
for k, _ := range ms.dict {
if strings.HasPrefix(k, utils.ALIASES_PREFIX) {
cache2go.RemKey(k)
if _, err := ms.GetAlias(k[len(utils.ALIASES_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
}
cache2go.CommitTransaction()
return nil
}
func (ms *MongoStorage) cacheAccounting(alsKeys []string) (err error) {
cache2go.BeginTransaction()
var keyResult struct{ Key string }
if alsKeys == nil {
cache2go.RemPrefixKey(utils.ALIASES_PREFIX)
}
if alsKeys == nil {
utils.Logger.Info("Caching all aliases")
iter := ms.db.C(colAls).Find(nil).Select(bson.M{"key": 1}).Iter()
alsKeys = make([]string, 0)
for iter.Next(&keyResult) {
alsKeys = append(alsKeys, utils.ALIASES_PREFIX+keyResult.Key)
}
if err := iter.Close(); err != nil {
cache2go.RollbackTransaction()
return err
}
} else if len(alsKeys) != 0 {
utils.Logger.Info(fmt.Sprintf("Caching aliases: %v", alsKeys))
}
for _, key := range alsKeys {
// check if it already exists
// to remove reverse cache keys
if avs, err := cache2go.Get(key); err == nil && avs != nil {
al := &Alias{Values: avs.(AliasValues)}
al.SetId(key[len(utils.ALIASES_PREFIX):])
al.RemoveReverseCache()
}
cache2go.RemKey(key)
if _, err = ms.GetAlias(key[len(utils.ALIASES_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(alsKeys) != 0 {
utils.Logger.Info("Finished aliases caching.")
}
utils.Logger.Info("Caching load history")
if _, err = ms.GetLoadHistory(1, true); err != nil {
cache2go.RollbackTransaction()
return err
}
utils.Logger.Info("Finished load history caching.")
cache2go.CommitTransaction()
return nil
}
// Sets a specific rating profile working with data directly in the RatingDb without involving storDb
func (self *ApierV1) SetRatingProfile(attrs AttrSetRatingProfile, reply *string) error {
if missing := utils.MissingStructFields(&attrs, []string{"Tenant", "TOR", "Direction", "Subject", "RatingPlanActivations"}); len(missing) != 0 {
return utils.NewErrMandatoryIeMissing(missing...)
}
for _, rpa := range attrs.RatingPlanActivations {
if missing := utils.MissingStructFields(rpa, []string{"ActivationTime", "RatingPlanId"}); len(missing) != 0 {
return fmt.Errorf("%s:RatingPlanActivation:%v", utils.ErrMandatoryIeMissing.Error(), missing)
}
}
tpRpf := utils.TPRatingProfile{Tenant: attrs.Tenant, Category: attrs.Category, Direction: attrs.Direction, Subject: attrs.Subject}
keyId := tpRpf.KeyId()
var rpfl *engine.RatingProfile
if !attrs.Overwrite {
if exists, err := self.RatingDb.HasData(utils.RATING_PROFILE_PREFIX, keyId); err != nil {
return utils.NewErrServerError(err)
} else if exists {
var err error
if rpfl, err = self.RatingDb.GetRatingProfile(keyId, false, utils.NonTransactional); err != nil {
return utils.NewErrServerError(err)
}
}
}
if rpfl == nil {
rpfl = &engine.RatingProfile{Id: keyId, RatingPlanActivations: make(engine.RatingPlanActivations, 0)}
}
for _, ra := range attrs.RatingPlanActivations {
at, err := utils.ParseTimeDetectLayout(ra.ActivationTime, self.Config.DefaultTimezone)
if err != nil {
return fmt.Errorf(fmt.Sprintf("%s:Cannot parse activation time from %v", utils.ErrServerError.Error(), ra.ActivationTime))
}
if exists, err := self.RatingDb.HasData(utils.RATING_PLAN_PREFIX, ra.RatingPlanId); err != nil {
return utils.NewErrServerError(err)
} else if !exists {
return fmt.Errorf(fmt.Sprintf("%s:RatingPlanId:%s", utils.ErrNotFound.Error(), ra.RatingPlanId))
}
rpfl.RatingPlanActivations = append(rpfl.RatingPlanActivations, &engine.RatingPlanActivation{ActivationTime: at, RatingPlanId: ra.RatingPlanId,
FallbackKeys: utils.FallbackSubjKeys(tpRpf.Direction, tpRpf.Tenant, tpRpf.Category, ra.FallbackSubjects)})
}
if err := self.RatingDb.SetRatingProfile(rpfl, utils.NonTransactional); err != nil {
return utils.NewErrServerError(err)
}
cache2go.RemPrefixKey(utils.RATING_PLAN_PREFIX, true, "")
self.RatingDb.PreloadCacheForPrefix(utils.RATING_PLAN_PREFIX)
*reply = OK
return nil
}
func (ms *MapStorage) cacheAccounting(alsKeys []string) error {
cache2go.BeginTransaction()
if alsKeys == nil {
cache2go.RemPrefixKey(utils.ALIASES_PREFIX) // Forced until we can fine tune it
}
for k, _ := range ms.dict {
if strings.HasPrefix(k, utils.ALIASES_PREFIX) {
// check if it already exists
// to remove reverse cache keys
if avs, err := cache2go.Get(k); err == nil && avs != nil {
al := &Alias{Values: avs.(AliasValues)}
al.SetId(k[len(utils.ALIASES_PREFIX):])
al.RemoveReverseCache()
}
cache2go.RemKey(k)
if _, err := ms.GetAlias(k[len(utils.ALIASES_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
}
cache2go.CommitTransaction()
return nil
}
func (ms *MongoStorage) cacheRating(dKeys, rpKeys, rpfKeys, lcrKeys, dcsKeys, actKeys, shgKeys []string) (err error) {
cache2go.BeginTransaction()
keyResult := struct{ Key string }{}
idResult := struct{ Id string }{}
if dKeys == nil || (float64(cache2go.CountEntries(utils.DESTINATION_PREFIX))*utils.DESTINATIONS_LOAD_THRESHOLD < float64(len(dKeys))) {
// if need to load more than a half of exiting keys load them all
utils.Logger.Info("Caching all destinations")
iter := ms.db.C(colDst).Find(nil).Select(bson.M{"id": 1}).Iter()
dKeys = make([]string, 0)
for iter.Next(&idResult) {
dKeys = append(dKeys, utils.DESTINATION_PREFIX+idResult.Id)
}
if err := iter.Close(); err != nil {
cache2go.RollbackTransaction()
return err
}
cache2go.RemPrefixKey(utils.DESTINATION_PREFIX)
} else if len(dKeys) != 0 {
utils.Logger.Info(fmt.Sprintf("Caching destinations: %v", dKeys))
CleanStalePrefixes(dKeys)
}
for _, key := range dKeys {
if len(key) <= len(utils.DESTINATION_PREFIX) {
utils.Logger.Warning(fmt.Sprintf("Got malformed destination id: %s", key))
continue
}
if _, err = ms.GetDestination(key[len(utils.DESTINATION_PREFIX):]); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(dKeys) != 0 {
utils.Logger.Info("Finished destinations caching.")
}
if rpKeys == nil {
utils.Logger.Info("Caching all rating plans")
iter := ms.db.C(colRpl).Find(nil).Select(bson.M{"id": 1}).Iter()
rpKeys = make([]string, 0)
for iter.Next(&idResult) {
rpKeys = append(rpKeys, utils.RATING_PLAN_PREFIX+idResult.Id)
}
if err := iter.Close(); err != nil {
cache2go.RollbackTransaction()
return err
}
cache2go.RemPrefixKey(utils.RATING_PLAN_PREFIX)
} else if len(rpKeys) != 0 {
utils.Logger.Info(fmt.Sprintf("Caching rating plans: %v", rpKeys))
}
for _, key := range rpKeys {
cache2go.RemKey(key)
if _, err = ms.GetRatingPlan(key[len(utils.RATING_PLAN_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(rpKeys) != 0 {
utils.Logger.Info("Finished rating plans caching.")
}
if rpfKeys == nil {
utils.Logger.Info("Caching all rating profiles")
iter := ms.db.C(colRpf).Find(nil).Select(bson.M{"id": 1}).Iter()
rpfKeys = make([]string, 0)
for iter.Next(&idResult) {
rpfKeys = append(rpfKeys, utils.RATING_PROFILE_PREFIX+idResult.Id)
}
if err := iter.Close(); err != nil {
cache2go.RollbackTransaction()
return err
}
cache2go.RemPrefixKey(utils.RATING_PROFILE_PREFIX)
} else if len(rpfKeys) != 0 {
utils.Logger.Info(fmt.Sprintf("Caching rating profile: %v", rpfKeys))
}
for _, key := range rpfKeys {
cache2go.RemKey(key)
if _, err = ms.GetRatingProfile(key[len(utils.RATING_PROFILE_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(rpfKeys) != 0 {
utils.Logger.Info("Finished rating profile caching.")
}
if lcrKeys == nil {
utils.Logger.Info("Caching LCR rules.")
iter := ms.db.C(colLcr).Find(nil).Select(bson.M{"key": 1}).Iter()
lcrKeys = make([]string, 0)
for iter.Next(&keyResult) {
lcrKeys = append(lcrKeys, utils.LCR_PREFIX+keyResult.Key)
}
if err := iter.Close(); err != nil {
cache2go.RollbackTransaction()
return err
}
cache2go.RemPrefixKey(utils.LCR_PREFIX)
} else if len(lcrKeys) != 0 {
utils.Logger.Info(fmt.Sprintf("Caching LCR rules: %v", lcrKeys))
}
for _, key := range lcrKeys {
cache2go.RemKey(key)
if _, err = ms.GetLCR(key[len(utils.LCR_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(lcrKeys) != 0 {
utils.Logger.Info("Finished LCR rules caching.")
}
// DerivedChargers caching
if dcsKeys == nil {
utils.Logger.Info("Caching all derived chargers")
iter := ms.db.C(colDcs).Find(nil).Select(bson.M{"key": 1}).Iter()
dcsKeys = make([]string, 0)
for iter.Next(&keyResult) {
dcsKeys = append(dcsKeys, utils.DERIVEDCHARGERS_PREFIX+keyResult.Key)
}
if err := iter.Close(); err != nil {
cache2go.RollbackTransaction()
return err
}
cache2go.RemPrefixKey(utils.DERIVEDCHARGERS_PREFIX)
} else if len(dcsKeys) != 0 {
utils.Logger.Info(fmt.Sprintf("Caching derived chargers: %v", dcsKeys))
}
for _, key := range dcsKeys {
cache2go.RemKey(key)
if _, err = ms.GetDerivedChargers(key[len(utils.DERIVEDCHARGERS_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(dcsKeys) != 0 {
utils.Logger.Info("Finished derived chargers caching.")
}
if actKeys == nil {
cache2go.RemPrefixKey(utils.ACTION_PREFIX)
}
if actKeys == nil {
utils.Logger.Info("Caching all actions")
iter := ms.db.C(colAct).Find(nil).Select(bson.M{"key": 1}).Iter()
actKeys = make([]string, 0)
for iter.Next(&keyResult) {
actKeys = append(actKeys, utils.ACTION_PREFIX+keyResult.Key)
}
if err := iter.Close(); err != nil {
cache2go.RollbackTransaction()
return err
}
cache2go.RemPrefixKey(utils.ACTION_PREFIX)
} else if len(actKeys) != 0 {
utils.Logger.Info(fmt.Sprintf("Caching actions: %v", actKeys))
}
for _, key := range actKeys {
cache2go.RemKey(key)
if _, err = ms.GetActions(key[len(utils.ACTION_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(actKeys) != 0 {
utils.Logger.Info("Finished actions caching.")
}
if shgKeys == nil {
cache2go.RemPrefixKey(utils.SHARED_GROUP_PREFIX)
}
if shgKeys == nil {
utils.Logger.Info("Caching all shared groups")
iter := ms.db.C(colShg).Find(nil).Select(bson.M{"id": 1}).Iter()
shgKeys = make([]string, 0)
for iter.Next(&idResult) {
shgKeys = append(shgKeys, utils.SHARED_GROUP_PREFIX+idResult.Id)
}
if err := iter.Close(); err != nil {
cache2go.RollbackTransaction()
return err
}
} else if len(shgKeys) != 0 {
utils.Logger.Info(fmt.Sprintf("Caching shared groups: %v", shgKeys))
}
for _, key := range shgKeys {
cache2go.RemKey(key)
if _, err = ms.GetSharedGroup(key[len(utils.SHARED_GROUP_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(shgKeys) != 0 {
utils.Logger.Info("Finished shared groups caching.")
}
cache2go.CommitTransaction()
return nil
}
func (rs *RedisStorage) cacheRating(dKeys, rpKeys, rpfKeys, lcrKeys, dcsKeys, actKeys, shgKeys []string) (err error) {
cache2go.BeginTransaction()
if dKeys == nil || (float64(cache2go.CountEntries(utils.DESTINATION_PREFIX))*utils.DESTINATIONS_LOAD_THRESHOLD < float64(len(dKeys))) {
// if need to load more than a half of exiting keys load them all
utils.Logger.Info("Caching all destinations")
if dKeys, err = rs.db.Keys(utils.DESTINATION_PREFIX + "*"); err != nil {
cache2go.RollbackTransaction()
return err
}
cache2go.RemPrefixKey(utils.DESTINATION_PREFIX)
} else if len(dKeys) != 0 {
utils.Logger.Info(fmt.Sprintf("Caching destinations: %v", dKeys))
CleanStalePrefixes(dKeys)
}
for _, key := range dKeys {
if len(key) <= len(utils.DESTINATION_PREFIX) {
utils.Logger.Warning(fmt.Sprintf("Got malformed destination id: %s", key))
continue
}
if _, err = rs.GetDestination(key[len(utils.DESTINATION_PREFIX):]); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(dKeys) != 0 {
utils.Logger.Info("Finished destinations caching.")
}
if rpKeys == nil {
utils.Logger.Info("Caching all rating plans")
if rpKeys, err = rs.db.Keys(utils.RATING_PLAN_PREFIX + "*"); err != nil {
cache2go.RollbackTransaction()
return err
}
cache2go.RemPrefixKey(utils.RATING_PLAN_PREFIX)
} else if len(rpKeys) != 0 {
utils.Logger.Info(fmt.Sprintf("Caching rating plans: %v", rpKeys))
}
for _, key := range rpKeys {
cache2go.RemKey(key)
if _, err = rs.GetRatingPlan(key[len(utils.RATING_PLAN_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(rpKeys) != 0 {
utils.Logger.Info("Finished rating plans caching.")
}
if rpfKeys == nil {
utils.Logger.Info("Caching all rating profiles")
if rpfKeys, err = rs.db.Keys(utils.RATING_PROFILE_PREFIX + "*"); err != nil {
cache2go.RollbackTransaction()
return err
}
cache2go.RemPrefixKey(utils.RATING_PROFILE_PREFIX)
} else if len(rpfKeys) != 0 {
utils.Logger.Info(fmt.Sprintf("Caching rating profile: %v", rpfKeys))
}
for _, key := range rpfKeys {
cache2go.RemKey(key)
if _, err = rs.GetRatingProfile(key[len(utils.RATING_PROFILE_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(rpfKeys) != 0 {
utils.Logger.Info("Finished rating profile caching.")
}
if lcrKeys == nil {
utils.Logger.Info("Caching LCR rules.")
if lcrKeys, err = rs.db.Keys(utils.LCR_PREFIX + "*"); err != nil {
cache2go.RollbackTransaction()
return err
}
cache2go.RemPrefixKey(utils.LCR_PREFIX)
} else if len(lcrKeys) != 0 {
utils.Logger.Info(fmt.Sprintf("Caching LCR rules: %v", lcrKeys))
}
for _, key := range lcrKeys {
cache2go.RemKey(key)
if _, err = rs.GetLCR(key[len(utils.LCR_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(lcrKeys) != 0 {
utils.Logger.Info("Finished LCR rules caching.")
}
// DerivedChargers caching
if dcsKeys == nil {
utils.Logger.Info("Caching all derived chargers")
if dcsKeys, err = rs.db.Keys(utils.DERIVEDCHARGERS_PREFIX + "*"); err != nil {
cache2go.RollbackTransaction()
return err
}
cache2go.RemPrefixKey(utils.DERIVEDCHARGERS_PREFIX)
} else if len(dcsKeys) != 0 {
utils.Logger.Info(fmt.Sprintf("Caching derived chargers: %v", dcsKeys))
}
for _, key := range dcsKeys {
cache2go.RemKey(key)
if _, err = rs.GetDerivedChargers(key[len(utils.DERIVEDCHARGERS_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(dcsKeys) != 0 {
utils.Logger.Info("Finished derived chargers caching.")
}
if actKeys == nil {
cache2go.RemPrefixKey(utils.ACTION_PREFIX)
}
if actKeys == nil {
utils.Logger.Info("Caching all actions")
if actKeys, err = rs.db.Keys(utils.ACTION_PREFIX + "*"); err != nil {
cache2go.RollbackTransaction()
return err
}
cache2go.RemPrefixKey(utils.ACTION_PREFIX)
} else if len(actKeys) != 0 {
utils.Logger.Info(fmt.Sprintf("Caching actions: %v", actKeys))
}
for _, key := range actKeys {
cache2go.RemKey(key)
if _, err = rs.GetActions(key[len(utils.ACTION_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(actKeys) != 0 {
utils.Logger.Info("Finished actions caching.")
}
if shgKeys == nil {
cache2go.RemPrefixKey(utils.SHARED_GROUP_PREFIX)
}
if shgKeys == nil {
utils.Logger.Info("Caching all shared groups")
if shgKeys, err = rs.db.Keys(utils.SHARED_GROUP_PREFIX + "*"); err != nil {
cache2go.RollbackTransaction()
return err
}
} else if len(shgKeys) != 0 {
utils.Logger.Info(fmt.Sprintf("Caching shared groups: %v", shgKeys))
}
for _, key := range shgKeys {
cache2go.RemKey(key)
if _, err = rs.GetSharedGroup(key[len(utils.SHARED_GROUP_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(shgKeys) != 0 {
utils.Logger.Info("Finished shared groups caching.")
}
cache2go.CommitTransaction()
return nil
}
func (ms *MapStorage) cacheRating(dKeys, rpKeys, rpfKeys, lcrKeys, dcsKeys, actKeys, aplKeys, shgKeys []string) error {
cache2go.BeginTransaction()
if dKeys == nil || (float64(cache2go.CountEntries(utils.DESTINATION_PREFIX))*utils.DESTINATIONS_LOAD_THRESHOLD < float64(len(dKeys))) {
cache2go.RemPrefixKey(utils.DESTINATION_PREFIX)
} else {
CleanStalePrefixes(dKeys)
}
if rpKeys == nil {
cache2go.RemPrefixKey(utils.RATING_PLAN_PREFIX)
}
if rpfKeys == nil {
cache2go.RemPrefixKey(utils.RATING_PROFILE_PREFIX)
}
if lcrKeys == nil {
cache2go.RemPrefixKey(utils.LCR_PREFIX)
}
if dcsKeys == nil {
cache2go.RemPrefixKey(utils.DERIVEDCHARGERS_PREFIX)
}
if actKeys == nil {
cache2go.RemPrefixKey(utils.ACTION_PREFIX) // Forced until we can fine tune it
}
if aplKeys == nil {
cache2go.RemPrefixKey(utils.ACTION_PLAN_PREFIX)
}
if shgKeys == nil {
cache2go.RemPrefixKey(utils.SHARED_GROUP_PREFIX) // Forced until we can fine tune it
}
for k, _ := range ms.dict {
if strings.HasPrefix(k, utils.DESTINATION_PREFIX) {
if _, err := ms.GetDestination(k[len(utils.DESTINATION_PREFIX):]); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if strings.HasPrefix(k, utils.RATING_PLAN_PREFIX) {
cache2go.RemKey(k)
if _, err := ms.GetRatingPlan(k[len(utils.RATING_PLAN_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if strings.HasPrefix(k, utils.RATING_PROFILE_PREFIX) {
cache2go.RemKey(k)
if _, err := ms.GetRatingProfile(k[len(utils.RATING_PROFILE_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if strings.HasPrefix(k, utils.LCR_PREFIX) {
cache2go.RemKey(k)
if _, err := ms.GetLCR(k[len(utils.LCR_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if strings.HasPrefix(k, utils.DERIVEDCHARGERS_PREFIX) {
cache2go.RemKey(k)
if _, err := ms.GetDerivedChargers(k[len(utils.DERIVEDCHARGERS_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if strings.HasPrefix(k, utils.ACTION_PREFIX) {
cache2go.RemKey(k)
if _, err := ms.GetActions(k[len(utils.ACTION_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if strings.HasPrefix(k, utils.ACTION_PLAN_PREFIX) {
cache2go.RemKey(k)
if _, err := ms.GetActionPlans(k[len(utils.ACTION_PLAN_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if strings.HasPrefix(k, utils.SHARED_GROUP_PREFIX) {
cache2go.RemKey(k)
if _, err := ms.GetSharedGroup(k[len(utils.SHARED_GROUP_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
}
cache2go.CommitTransaction()
return nil
}
func (rs *RedisStorage) UpdateReverseAlias(oldAl, newAl *Alias, transactionID string) error {
// FIXME: thi can be optimized
cache2go.RemPrefixKey(utils.REVERSE_ALIASES_PREFIX, cacheCommit(transactionID), transactionID)
rs.SetReverseAlias(newAl, transactionID)
return nil
}
func (rs *RedisStorage) CacheRating(dKeys, rpKeys, rpfKeys, alsKeys, lcrKeys []string) (err error) {
cache2go.BeginTransaction()
if dKeys == nil {
Logger.Info("Caching all destinations")
if dKeys, err = rs.db.Keys(DESTINATION_PREFIX + "*"); err != nil {
cache2go.RollbackTransaction()
return err
}
cache2go.RemPrefixKey(DESTINATION_PREFIX)
} else if len(dKeys) != 0 {
Logger.Info(fmt.Sprintf("Caching destinations: %v", dKeys))
CleanStalePrefixes(dKeys)
}
for _, key := range dKeys {
if _, err = rs.GetDestination(key[len(DESTINATION_PREFIX):]); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(dKeys) != 0 {
Logger.Info("Finished destinations caching.")
}
if rpKeys == nil {
Logger.Info("Caching all rating plans")
if rpKeys, err = rs.db.Keys(RATING_PLAN_PREFIX + "*"); err != nil {
cache2go.RollbackTransaction()
return err
}
cache2go.RemPrefixKey(RATING_PLAN_PREFIX)
} else if len(rpKeys) != 0 {
Logger.Info(fmt.Sprintf("Caching rating plans: %v", rpKeys))
}
for _, key := range rpKeys {
cache2go.RemKey(key)
if _, err = rs.GetRatingPlan(key[len(RATING_PLAN_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(rpKeys) != 0 {
Logger.Info("Finished rating plans caching.")
}
if rpfKeys == nil {
Logger.Info("Caching all rating profiles")
if rpfKeys, err = rs.db.Keys(RATING_PROFILE_PREFIX + "*"); err != nil {
cache2go.RollbackTransaction()
return err
}
cache2go.RemPrefixKey(RATING_PROFILE_PREFIX)
} else if len(rpfKeys) != 0 {
Logger.Info(fmt.Sprintf("Caching rating profile: %v", rpfKeys))
}
for _, key := range rpfKeys {
cache2go.RemKey(key)
if _, err = rs.GetRatingProfile(key[len(RATING_PROFILE_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(rpfKeys) != 0 {
Logger.Info("Finished rating profile caching.")
}
if lcrKeys == nil {
Logger.Info("Caching LCRs")
if lcrKeys, err = rs.db.Keys(LCR_PREFIX + "*"); err != nil {
cache2go.RollbackTransaction()
return err
}
cache2go.RemPrefixKey(LCR_PREFIX)
} else if len(lcrKeys) != 0 {
Logger.Info(fmt.Sprintf("Caching LCR: %v", lcrKeys))
}
for _, key := range lcrKeys {
cache2go.RemKey(key)
if _, err = rs.GetLCR(key[len(LCR_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(lcrKeys) != 0 {
Logger.Info("Finished rating profile caching.")
}
if alsKeys == nil {
Logger.Info("Caching all rating subject aliases.")
if alsKeys, err = rs.db.Keys(RP_ALIAS_PREFIX + "*"); err != nil {
cache2go.RollbackTransaction()
return err
}
cache2go.RemPrefixKey(RP_ALIAS_PREFIX)
} else if len(alsKeys) != 0 {
Logger.Info(fmt.Sprintf("Caching rating subject aliases: %v", alsKeys))
}
for _, key := range alsKeys {
cache2go.RemKey(key)
if _, err = rs.GetRpAlias(key[len(RP_ALIAS_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(alsKeys) != 0 {
Logger.Info("Finished rating profile aliases caching.")
}
cache2go.CommitTransaction()
return nil
}
func (rs *RedisStorage) CacheAccounting(actKeys, shgKeys, alsKeys, dcsKeys []string) (err error) {
cache2go.BeginTransaction()
if actKeys == nil {
cache2go.RemPrefixKey(ACTION_PREFIX)
}
if actKeys == nil {
Logger.Info("Caching all actions")
if actKeys, err = rs.db.Keys(ACTION_PREFIX + "*"); err != nil {
cache2go.RollbackTransaction()
return err
}
} else if len(actKeys) != 0 {
Logger.Info(fmt.Sprintf("Caching actions: %v", actKeys))
}
for _, key := range actKeys {
cache2go.RemKey(key)
if _, err = rs.GetActions(key[len(ACTION_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(actKeys) != 0 {
Logger.Info("Finished actions caching.")
}
if shgKeys == nil {
cache2go.RemPrefixKey(SHARED_GROUP_PREFIX)
}
if shgKeys == nil {
Logger.Info("Caching all shared groups")
if shgKeys, err = rs.db.Keys(SHARED_GROUP_PREFIX + "*"); err != nil {
cache2go.RollbackTransaction()
return err
}
} else if len(shgKeys) != 0 {
Logger.Info(fmt.Sprintf("Caching shared groups: %v", shgKeys))
}
for _, key := range shgKeys {
cache2go.RemKey(key)
if _, err = rs.GetSharedGroup(key[len(SHARED_GROUP_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(shgKeys) != 0 {
Logger.Info("Finished shared groups caching.")
}
if alsKeys == nil {
Logger.Info("Caching all account aliases.")
if alsKeys, err = rs.db.Keys(ACC_ALIAS_PREFIX + "*"); err != nil {
cache2go.RollbackTransaction()
return err
}
cache2go.RemPrefixKey(ACC_ALIAS_PREFIX)
} else if len(alsKeys) != 0 {
Logger.Info(fmt.Sprintf("Caching account aliases: %v", alsKeys))
}
for _, key := range alsKeys {
cache2go.RemKey(key)
if _, err = rs.GetAccAlias(key[len(ACC_ALIAS_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(alsKeys) != 0 {
Logger.Info("Finished account aliases caching.")
}
// DerivedChargers caching
if dcsKeys == nil {
Logger.Info("Caching all derived chargers")
if dcsKeys, err = rs.db.Keys(DERIVEDCHARGERS_PREFIX + "*"); err != nil {
cache2go.RollbackTransaction()
return err
}
cache2go.RemPrefixKey(DERIVEDCHARGERS_PREFIX)
} else if len(dcsKeys) != 0 {
Logger.Info(fmt.Sprintf("Caching derived chargers: %v", dcsKeys))
}
for _, key := range dcsKeys {
cache2go.RemKey(key)
if _, err = rs.GetDerivedChargers(key[len(DERIVEDCHARGERS_PREFIX):], true); err != nil {
cache2go.RollbackTransaction()
return err
}
}
if len(dcsKeys) != 0 {
Logger.Info("Finished derived chargers caching.")
}
cache2go.CommitTransaction()
return nil
}